Robust LOWESS target curve with intentional exposure offsets removed, blended by Tukey weight and surviving-window fraction; flicker spectrum from the autocorrelation of detrended luminance recommends a window of four periods. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
97 lines
4.4 KiB
C#
97 lines
4.4 KiB
C#
using System.Globalization;
|
|
using Titano.Core.Analysis;
|
|
using Titano.Core.Diagnostics.Synthetic;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Core.Tests.Analysis;
|
|
|
|
public sealed class DeflickerEngineTests(TestContext context)
|
|
{
|
|
/// <summary>BRIEF §20.4: flicker reduction ≥ 60 % on the synthetic ramp with the ramp preserved within 0.05 EV,
|
|
/// measured end to end (measure → target curve → apply gains → re-measure).</summary>
|
|
[Test]
|
|
public void RampSequenceMeetsTheRegressionGate()
|
|
{
|
|
var sequence = SyntheticSequence.Create(new SyntheticSequenceOptions
|
|
{
|
|
FrameCount = 200,
|
|
Seed = 3,
|
|
StartEv = -2,
|
|
EndEv = 1,
|
|
FlickerEv = 0.1,
|
|
});
|
|
var measured = AnalysisFixtures.MeasureSeries(sequence);
|
|
var result = DeflickerEngine.Compute(measured, new DeflickerOptions { Window = 21 });
|
|
var corrected = AnalysisFixtures.MeasureSeries(sequence, (i, image) =>
|
|
{
|
|
ExposureProcessor.Apply(image, result.CorrectionEv[i]);
|
|
return image;
|
|
});
|
|
|
|
var before = AnalysisFixtures.FrameToFrameResidualRms(measured, sequence.SceneEv);
|
|
var after = AnalysisFixtures.FrameToFrameResidualRms(corrected, sequence.SceneEv);
|
|
var reduction = 1 - after / before;
|
|
var rampError = AnalysisFixtures.MaxDeviation(corrected, sequence.SceneEv);
|
|
context.Log(string.Create(CultureInfo.InvariantCulture,
|
|
$"flicker before {before:F4} EV, after {after:F4} EV, reduction {reduction:P1}, max ramp deviation {rampError:F4} EV, diagnostics {result.Diagnostics}"));
|
|
Assert.GreaterOrEqual(reduction, 0.60);
|
|
Assert.LessOrEqual(rampError, 0.05);
|
|
Assert.Approximately(after, result.Diagnostics.FlickerAfter, 0.01);
|
|
Assert.Approximately(before, result.Diagnostics.FlickerBefore, 0.02);
|
|
}
|
|
|
|
[Test]
|
|
public void IntentionalOffsetsAreNotTreatedAsFlicker()
|
|
{
|
|
var n = 120;
|
|
var ramp = Enumerable.Range(0, n).Select(i => -0.01 * i).ToArray();
|
|
var offsets = Enumerable.Range(0, n).Select(i => i >= 60 ? 1.0 : 0.0).ToArray();
|
|
var measured = ramp.Select((v, i) => v + offsets[i]).ToArray();
|
|
var withOffsets = DeflickerEngine.Compute(measured, intentionalOffsets: offsets);
|
|
for (var i = 0; i < n; i++) Assert.Approximately(measured[i], withOffsets.Target[i], 1e-9);
|
|
|
|
// Without them the step is smeared into a ramp over the window.
|
|
var naive = DeflickerEngine.Compute(measured);
|
|
Assert.Greater(Math.Abs(naive.CorrectionEv[59]), 0.2);
|
|
}
|
|
|
|
[Test]
|
|
public void OutliersArePulledOntoTheFitAndStrengthBlendsTheRest()
|
|
{
|
|
var random = new Random(8);
|
|
var n = 150;
|
|
var truth = Enumerable.Range(0, n).Select(i => 0.02 * i).ToArray();
|
|
var measured = truth.Select(v => v + 0.05 * (2 * random.NextDouble() - 1)).ToArray();
|
|
measured[70] += 2.5;
|
|
var half = DeflickerEngine.Compute(measured, new DeflickerOptions { Strength = 0.5 });
|
|
Assert.Less(half.RobustWeights[70], 0.01);
|
|
Assert.Approximately(truth[70], half.Target[70], 0.05);
|
|
Assert.Equal(1, half.Diagnostics.OutlierCount);
|
|
|
|
// An inlier keeps about half of its own deviation from the fit.
|
|
var inlier = Enumerable.Range(0, n).First(i => i is > 10 and < 140 && Math.Abs(measured[i] - half.Fitted[i]) > 0.02 && half.RobustWeights[i] > 0.8);
|
|
var kept = (half.Target[inlier] - half.Fitted[inlier]) / (measured[inlier] - half.Fitted[inlier]);
|
|
Assert.InRange(kept, 0.5 * half.RobustWeights[inlier] * half.SurvivingFraction[inlier] - 1e-9, 0.5 + 1e-9);
|
|
Assert.Greater(kept, 0.35);
|
|
}
|
|
|
|
[Test]
|
|
public void UnusableFramesGetTargetsButNoCorrection()
|
|
{
|
|
var measured = Enumerable.Range(0, 40).Select(i => 0.1 * i).ToArray();
|
|
measured[12] = double.NaN;
|
|
var result = DeflickerEngine.Compute(measured, new DeflickerOptions { Window = 9 });
|
|
Assert.Approximately(1.2, result.Target[12], 1e-9);
|
|
Assert.Equal(0.0, result.CorrectionEv[12]);
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => DeflickerEngine.Compute(measured, new DeflickerOptions { Strength = 2 }));
|
|
}
|
|
|
|
[Test]
|
|
public void OffsetsFromExposureFollowMetadata()
|
|
{
|
|
double?[] ev = [null, 12, 12, 11.5, null, 13];
|
|
var offsets = DeflickerEngine.OffsetsFromExposure(ev);
|
|
Assert.SequenceEqual([0.0, 0, 0, 0.5, 0.5, -1], offsets);
|
|
}
|
|
}
|