225 lines
9.8 KiB
C#
225 lines
9.8 KiB
C#
using System.IO;
|
||
using System.Windows.Media;
|
||
using System.Windows.Media.Imaging;
|
||
using Xunit;
|
||
using ytLive.Models;
|
||
using ytLive.Services;
|
||
using ytLive.Services.BackgroundEffects;
|
||
|
||
namespace ytLive.Tests;
|
||
|
||
/// <summary>TASK 51 slice 1 — the background-effects engine.</summary>
|
||
public class BackgroundEffectEngineTests
|
||
{
|
||
private sealed class FakeSegmenter : IPersonSegmenter
|
||
{
|
||
private readonly SegmentationMask? _mask;
|
||
public int Calls;
|
||
public FakeSegmenter(SegmentationMask? mask) => _mask = mask;
|
||
public SegmentationMask? Segment(VideoFrame frame)
|
||
{
|
||
Calls++;
|
||
return _mask;
|
||
}
|
||
}
|
||
|
||
/// <summary>The integration test for this unit: a webcam frame run through the
|
||
/// processor with Remove comes back with the person kept and the background
|
||
/// transparent, colors untouched, flagged non-opaque so the compositor blends it.
|
||
/// None is a true passthrough (same instance, segmenter never called).</summary>
|
||
[Fact]
|
||
public void Remove_keeps_the_person_and_makes_the_background_transparent()
|
||
{
|
||
const int w = 64, h = 32;
|
||
var pixels = new byte[w * h * 4];
|
||
for (var i = 0; i < pixels.Length; i += 4)
|
||
{
|
||
pixels[i] = 10; pixels[i + 1] = 20; pixels[i + 2] = 30; pixels[i + 3] = 255;
|
||
}
|
||
var frame = new VideoFrame(w, h, pixels) { IsOpaque = true };
|
||
|
||
// 4×2 mask: left half person, right half background.
|
||
var mask = new SegmentationMask(4, 2, new[] { 1f, 1f, 0f, 0f, 1f, 1f, 0f, 0f });
|
||
var segmenter = new FakeSegmenter(mask);
|
||
var processor = new BackgroundEffectProcessor(segmenter);
|
||
|
||
Assert.Same(frame, processor.Apply(frame, BackgroundEffect.None));
|
||
Assert.Equal(0, segmenter.Calls);
|
||
|
||
var result = processor.Apply(frame, BackgroundEffect.Remove);
|
||
|
||
Assert.NotSame(frame, result);
|
||
Assert.False(result.IsOpaque);
|
||
Assert.Equal(w, result.Width);
|
||
Assert.Equal(h, result.Height);
|
||
for (var y = 0; y < h; y++)
|
||
{
|
||
Assert.Equal(255, Alpha(result, 4, y)); // well inside the person half
|
||
Assert.Equal(0, Alpha(result, w - 5, y)); // well inside the background half
|
||
}
|
||
for (var i = 0; i < pixels.Length; i += 4)
|
||
{
|
||
Assert.Equal(pixels[i], result.BgraPixels[i]);
|
||
Assert.Equal(pixels[i + 1], result.BgraPixels[i + 1]);
|
||
Assert.Equal(pixels[i + 2], result.BgraPixels[i + 2]);
|
||
}
|
||
Assert.Equal(255, frame.BgraPixels[(w - 5) * 4 + 3]); // source frame never mutated
|
||
}
|
||
|
||
/// <summary>Model contract: the BUNDLED (embedded) ONNX model, driven through the C#
|
||
/// preprocessing, reproduces Google's own MediaPipe runtime on a fixed fixture.
|
||
/// The expected mask was produced by tools/selfie-seg/ running the original .tflite in
|
||
/// MediaPipe (fixture: MediaPipe's public test image mozart_square.jpg, a public-domain
|
||
/// painting, cropped to 256×144). Guards the embedding, the input layout (RGB, NHWC,
|
||
/// /255) and the conversion itself.</summary>
|
||
[Fact]
|
||
public void Bundled_model_matches_the_MediaPipe_reference_mask()
|
||
{
|
||
var frame = LoadBgra(Fixture("selfie-fixture-256x144.png"));
|
||
var expected = LoadBgra(Fixture("selfie-fixture-expected-mask.png"));
|
||
|
||
using var segmenter = new OnnxPersonSegmenter();
|
||
var mask = segmenter.Segment(frame);
|
||
|
||
Assert.NotNull(mask);
|
||
Assert.Equal(OnnxPersonSegmenter.ModelWidth, mask!.Width);
|
||
Assert.Equal(OnnxPersonSegmenter.ModelHeight, mask.Height);
|
||
|
||
var agree = 0;
|
||
var person = 0;
|
||
for (var i = 0; i < mask.Width * mask.Height; i++)
|
||
{
|
||
var expectPerson = expected.BgraPixels[i * 4] > 127;
|
||
var gotPerson = mask.Values[i] > 0.5f;
|
||
if (expectPerson == gotPerson) agree++;
|
||
if (gotPerson) person++;
|
||
}
|
||
var total = mask.Width * mask.Height;
|
||
Assert.True(agree >= total * 0.995, $"binary agreement {100.0 * agree / total:0.00}% < 99.5%");
|
||
Assert.InRange(100.0 * person / total, 45, 60); // reference: 52.5% person
|
||
}
|
||
|
||
/// <summary>Slice 2 integration test: Blur keeps the person pixel-for-pixel and smooths the
|
||
/// background — a 1px black/white checkerboard behind the "person" comes back as mid-tones,
|
||
/// opaque, same size.</summary>
|
||
[Fact]
|
||
public void Blur_keeps_the_person_sharp_and_smooths_the_background()
|
||
{
|
||
const int w = 64, h = 32;
|
||
var pixels = new byte[w * h * 4];
|
||
for (var y = 0; y < h; y++)
|
||
for (var x = 0; x < w; x++)
|
||
{
|
||
var p = (y * w + x) * 4;
|
||
if (x < w / 2)
|
||
{
|
||
pixels[p] = 100; pixels[p + 1] = 150; pixels[p + 2] = 200;
|
||
}
|
||
else
|
||
{
|
||
var v = (byte)(((x + y) & 1) == 0 ? 0 : 255);
|
||
pixels[p] = v; pixels[p + 1] = v; pixels[p + 2] = v;
|
||
}
|
||
pixels[p + 3] = 255;
|
||
}
|
||
var frame = new VideoFrame(w, h, pixels) { IsOpaque = true };
|
||
var mask = new SegmentationMask(4, 2, new[] { 1f, 1f, 0f, 0f, 1f, 1f, 0f, 0f });
|
||
var processor = new BackgroundEffectProcessor(new FakeSegmenter(mask));
|
||
|
||
var result = processor.Apply(frame, BackgroundEffect.Blur);
|
||
|
||
Assert.NotSame(frame, result);
|
||
Assert.True(result.IsOpaque);
|
||
Assert.Equal(w, result.Width);
|
||
Assert.Equal(h, result.Height);
|
||
for (var y = 0; y < h; y++)
|
||
{
|
||
for (var x = 0; x < 24; x++) // person: untouched
|
||
for (var c = 0; c < 4; c++)
|
||
Assert.Equal(pixels[(y * w + x) * 4 + c], result.BgraPixels[(y * w + x) * 4 + c]);
|
||
for (var x = 44; x < w; x++) // background: checkerboard smoothed away
|
||
{
|
||
var p = (y * w + x) * 4;
|
||
for (var c = 0; c < 3; c++)
|
||
Assert.InRange(result.BgraPixels[p + c], (byte)30, (byte)225);
|
||
Assert.Equal(255, result.BgraPixels[p + 3]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>TASK 51 blur-heavy fix — the integration test: an all-background frame with one
|
||
/// bright pixel. The default 0.5 strength must keep the halo tight (quadratic curve: radius 2
|
||
/// small px) while full strength spreads it far (radius 6) — the maker complained the default
|
||
/// was heavy under the old linear 1..12 range.</summary>
|
||
[Fact]
|
||
public void Blur_default_strength_is_gentle_and_full_strength_is_strong()
|
||
{
|
||
const int w = 128, h = 64;
|
||
var pixels = new byte[w * h * 4];
|
||
for (var y = 0; y < h; y++)
|
||
for (var x = 0; x < w; x++)
|
||
{
|
||
var p = (y * w + x) * 4;
|
||
if (x < w / 2) pixels[p] = 200;
|
||
pixels[p + 1] = 180;
|
||
pixels[p + 2] = 160;
|
||
pixels[p + 3] = 255;
|
||
}
|
||
var frame = new VideoFrame(w, h, pixels) { IsOpaque = true };
|
||
|
||
// All background — the whole frame blurs, no person boundary to confuse the edge spread.
|
||
var mask = new SegmentationMask(4, 2, new float[8]);
|
||
var processor = new BackgroundEffectProcessor(new FakeSegmenter(mask));
|
||
|
||
var gentle = processor.Apply(frame, BackgroundEffect.Blur, BackgroundEffectProcessor.DefaultStrength);
|
||
var strong = processor.Apply(frame, BackgroundEffect.Blur, 1.0);
|
||
|
||
// The radius mapping itself: quadratic, not the old linear 1..12. Default 0.5 = 2 small px
|
||
// (was 6), max = 6 small px (was 12) — the reason the default felt heavy before.
|
||
Assert.Equal(1, BackgroundEffectProcessor.BlurRadius(0.0));
|
||
Assert.Equal(2, BackgroundEffectProcessor.BlurRadius(BackgroundEffectProcessor.DefaultStrength));
|
||
Assert.Equal(BackgroundEffectProcessor.MinBlurRadius, BackgroundEffectProcessor.BlurRadius(0.0));
|
||
Assert.Equal(BackgroundEffectProcessor.MaxBlurRadius, BackgroundEffectProcessor.BlurRadius(1.0));
|
||
|
||
// Behaviour at a step edge: the default smears light only ~9px into the dark half (measured),
|
||
// full strength smears ~26px — a gentle default with a real range above it.
|
||
var (reachGentle, sumGentle) = EdgeReach(gentle);
|
||
var (reachStrong, sumStrong) = EdgeReach(strong);
|
||
Assert.True(reachGentle <= 12, $"default blur reach {reachGentle}px (expected <= 12)");
|
||
Assert.True(reachStrong >= 20, $"max blur reach {reachStrong}px (expected >= 20)");
|
||
Assert.True(reachStrong > reachGentle);
|
||
Assert.True(sumStrong > sumGentle * 2, "max strength should smear visibly more light than default");
|
||
}
|
||
|
||
/// <summary>Largest x into the dark half (x = w/2) still carrying light, and the total light
|
||
/// in the dark half — the blur's smearing distance at a step edge.</summary>
|
||
private static (int Reach, double Sum) EdgeReach(VideoFrame f)
|
||
{
|
||
var edge = f.Width / 2;
|
||
var reach = 0;
|
||
double sum = 0;
|
||
for (var y = 0; y < f.Height; y++)
|
||
for (var x = edge; x < f.Width; x++)
|
||
{
|
||
var v = f.BgraPixels[(y * f.Width + x) * 4];
|
||
if (v >= 32) reach = Math.Max(reach, x - edge);
|
||
sum += v;
|
||
}
|
||
return (reach, sum);
|
||
}
|
||
|
||
private static int Alpha(VideoFrame f, int x, int y) => f.BgraPixels[(y * f.Width + x) * 4 + 3];
|
||
|
||
private static string Fixture(string name) => Path.Combine(AppContext.BaseDirectory, "Fixtures", name);
|
||
|
||
private static VideoFrame LoadBgra(string path)
|
||
{
|
||
using var stream = File.OpenRead(path);
|
||
var decoded = BitmapDecoder.Create(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad).Frames[0];
|
||
var bgra = new FormatConvertedBitmap(decoded, PixelFormats.Bgra32, null, 0);
|
||
var pixels = new byte[bgra.PixelWidth * bgra.PixelHeight * 4];
|
||
bgra.CopyPixels(pixels, bgra.PixelWidth * 4, 0);
|
||
return new VideoFrame(bgra.PixelWidth, bgra.PixelHeight, pixels);
|
||
}
|
||
}
|