public void MultiplyFunction <TPixel>(TestPixel <TPixel> back, TestPixel <TPixel> source, float amount, TestPixel <TPixel> expected) where TPixel : struct, IPixel <TPixel> { TPixel actual = PorterDuffFunctions <TPixel> .MultiplyFunction(back, source, amount); VectorAssert.Equal(expected, actual, 2); }
private void BulkVectorConvert <TPixel>(BufferSpan <TPixel> destination, BufferSpan <TPixel> background, BufferSpan <TPixel> source, BufferSpan <float> amount) where TPixel : struct, IPixel <TPixel> { Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length)); Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); using (Buffer <Vector4> buffer = new Buffer <Vector4>(destination.Length * 3)) { BufferSpan <Vector4> destinationSpan = buffer.Slice(0, destination.Length); BufferSpan <Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length); BufferSpan <Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length); PixelOperations <TPixel> .Instance.ToVector4(background, backgroundSpan, destination.Length); PixelOperations <TPixel> .Instance.ToVector4(source, sourceSpan, destination.Length); for (int i = 0; i < destination.Length; i++) { destinationSpan[i] = PorterDuffFunctions.NormalBlendFunction(backgroundSpan[i], sourceSpan[i], amount[i]); } PixelOperations <TPixel> .Instance.PackFromVector4(destinationSpan, destination, destination.Length); } }
public void HardLightFunction <TPixel>(TestPixel <TPixel> back, TestPixel <TPixel> source, float amount, TestPixel <TPixel> expected) where TPixel : struct, IPixel <TPixel> { TPixel actual = PorterDuffFunctions.HardLightSrcOver(back.AsPixel(), source.AsPixel(), amount); VectorAssert.Equal(expected.AsPixel(), actual, 2); }
private void BulkVectorConvert <TPixel>(Span <TPixel> destination, Span <TPixel> background, Span <TPixel> source, Span <float> amount) where TPixel : struct, IPixel <TPixel> { Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length)); Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length)); using (IMemoryOwner <Vector4> buffer = Configuration.Default.MemoryAllocator.Allocate <Vector4>(destination.Length * 3)) { Span <Vector4> destinationSpan = buffer.Slice(0, destination.Length); Span <Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length); Span <Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length); PixelOperations <TPixel> .Instance.ToVector4(background, backgroundSpan, destination.Length); PixelOperations <TPixel> .Instance.ToVector4(source, sourceSpan, destination.Length); for (int i = 0; i < destination.Length; i++) { destinationSpan[i] = PorterDuffFunctions.Normal(backgroundSpan[i], sourceSpan[i], amount[i]); } PixelOperations <TPixel> .Instance.PackFromVector4(destinationSpan, destination, destination.Length); } }
public void LightenFunction <TPixel>(TestPixel <TPixel> back, TestPixel <TPixel> source, float amount, TestPixel <TPixel> expected) where TPixel : struct, IPixel <TPixel> { TPixel actual = PorterDuffFunctions.LightenSrcOver((TPixel)back, source, amount); VectorAssert.Equal(expected, actual, 2); }
public void NormalBlendFunction <TPixel>(TestPixel <TPixel> back, TestPixel <TPixel> source, float amount, TestPixel <TPixel> expected) where TPixel : struct, IPixel <TPixel> { TPixel actual = PorterDuffFunctions.Normal((TPixel)(TPixel)back, source, amount); VectorAssert.Equal(expected, actual, 2); }
public void MultiplyFunction <TPixel>(TestPixel <TPixel> back, TestPixel <TPixel> source, float amount, TestPixel <TPixel> expected) where TPixel : unmanaged, IPixel <TPixel> { TPixel actual = PorterDuffFunctions.MultiplySrcOver(back.AsPixel(), source.AsPixel(), amount); VectorAssert.Equal(expected.AsPixel(), actual, 2); }
/// <summary> /// Base implementation of the indexer for gradients /// (follows the facade pattern, using abstract methods) /// </summary> /// <param name="x">X coordinate of the Pixel.</param> /// <param name="y">Y coordinate of the Pixel.</param> internal override TPixel this[int x, int y] { get { float positionOnCompleteGradient = this.PositionOnGradient(x + 0.5f, y + 0.5f); switch (this.repetitionMode) { case GradientRepetitionMode.None: // do nothing. The following could be done, but is not necessary: // onLocalGradient = Math.Min(0, Math.Max(1, onLocalGradient)); break; case GradientRepetitionMode.Repeat: positionOnCompleteGradient %= 1; break; case GradientRepetitionMode.Reflect: positionOnCompleteGradient %= 2; if (positionOnCompleteGradient > 1) { positionOnCompleteGradient = 2 - positionOnCompleteGradient; } break; case GradientRepetitionMode.DontFill: if (positionOnCompleteGradient > 1 || positionOnCompleteGradient < 0) { return(Transparent); } break; default: throw new ArgumentOutOfRangeException(); } (ColorStop from, ColorStop to) = this.GetGradientSegment(positionOnCompleteGradient); if (from.Color.Equals(to.Color)) { return(from.Color.ToPixel <TPixel>()); } else { var fromAsVector = from.Color.ToVector4(); var toAsVector = to.Color.ToVector4(); float onLocalGradient = (positionOnCompleteGradient - from.Ratio) / (to.Ratio - from.Ratio); // TODO: this should be changeble for different gradienting functions Vector4 result = PorterDuffFunctions.NormalSrcOver( fromAsVector, toAsVector, onLocalGradient); TPixel resultColor = default; resultColor.FromVector4(result); return(resultColor); } } }
private void BulkPixelConvert <TPixel>(Span <TPixel> destination, Span <TPixel> background, Span <TPixel> source, Span <float> amount) where TPixel : struct, IPixel <TPixel> { Guard.MustBeGreaterThanOrEqualTo(destination.Length, background.Length, nameof(destination)); Guard.MustBeGreaterThanOrEqualTo(source.Length, background.Length, nameof(destination)); Guard.MustBeGreaterThanOrEqualTo(amount.Length, background.Length, nameof(destination)); for (int i = 0; i < destination.Length; i++) { destination[i] = PorterDuffFunctions.Normal(destination[i], source[i], amount[i]); } }
public void ScreenFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected) { Vector4 actual = PorterDuffFunctions.ScreenSrcOver((Vector4)back, source, amount); VectorAssert.Equal(expected, actual, 5); }
public void NormalBlendFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected) { Vector4 actual = PorterDuffFunctions.NormalSrcOver((Vector4)back, source, amount); Assert.Equal(expected, actual); }
public void SubstractFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected) { Vector4 actual = PorterDuffFunctions.Subtract((Vector4)back, source, amount); VectorAssert.Equal(expected, actual, 5); }
public void AddFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected) { Vector4 actual = PorterDuffFunctions.Multiply((Vector4)back, source, amount); VectorAssert.Equal(expected, actual, 5); }
public void HardLightFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected) { Vector4 actual = PorterDuffFunctions.HardLightFunction(back, source, amount); VectorAssert.Equal(expected, actual, 5); }