feat(analysis): add sky/land segmentation and region deflicker
Horizon from the strongest column-averaged row step (median over frames), refined per column by a dynamic-programming path and feathered; Otsu luminance fallback with morphology; confidences for both. Region deflicker fits sky and land separately and blends through the mask. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
4 files changed
+712
No files matched your search
@@ -0,0 +1,43 @@
|
||||
using Titano.Core.Imaging;
|
||||
|
||||
namespace Titano.Core.Analysis;
|
||||
|
||||
/// <summary>Independent deflicker curves for the sky and land regions.</summary>
|
||||
public sealed record RegionDeflickerResult(DeflickerResult Sky, DeflickerResult Land);
|
||||
|
||||
/// <summary>
|
||||
/// Region deflicker (BRIEF §11.2): sky and land are measured through the soft <see cref="RegionMask"/>, each gets its
|
||||
/// own <see cref="DeflickerEngine"/> target curve, and the two corrections are blended per pixel through the mask.
|
||||
/// Use it when the regions flicker independently (moving clouds, city lights) and the mask confidence is high.
|
||||
/// </summary>
|
||||
public static class RegionDeflicker
|
||||
{
|
||||
/// <summary>Trimmed-mean log2 luminance of the sky and land regions of one analysis image.</summary>
|
||||
public static (double Sky, double Land) Measure(ImageBuffer analysisImage, RegionMask mask, double trimLow = 0.02, double trimHigh = 0.02)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(analysisImage);
|
||||
ArgumentNullException.ThrowIfNull(mask);
|
||||
if (mask.Width != analysisImage.Width || mask.Height != analysisImage.Height)
|
||||
throw new ArgumentException("Mask and image sizes differ.", nameof(mask));
|
||||
return (FrameStatistics.MeasureLogLuminance(analysisImage, mask.Sky, trimLow, trimHigh),
|
||||
FrameStatistics.MeasureLogLuminance(analysisImage, mask.Land, trimLow, trimHigh));
|
||||
}
|
||||
|
||||
public static RegionDeflickerResult Compute(ReadOnlySpan<double> skyLogLuminance, ReadOnlySpan<double> landLogLuminance, DeflickerOptions? options = null, ReadOnlySpan<double> intentionalOffsets = default)
|
||||
{
|
||||
if (skyLogLuminance.Length != landLogLuminance.Length) throw new ArgumentException("Series lengths differ.", nameof(landLogLuminance));
|
||||
return new RegionDeflickerResult(
|
||||
DeflickerEngine.Compute(skyLogLuminance, options, intentionalOffsets),
|
||||
DeflickerEngine.Compute(landLogLuminance, options, intentionalOffsets));
|
||||
}
|
||||
|
||||
/// <summary>Applies one frame's sky and land corrections (EV) in place; the mask is resampled to the image size
|
||||
/// when needed (resample once up front when rendering many frames).</summary>
|
||||
public static void Apply(ImageBuffer image, RegionMask mask, double skyEv, double landEv, ChannelGains? gains = null, double? softClipKnee = null)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(image);
|
||||
ArgumentNullException.ThrowIfNull(mask);
|
||||
var fitted = mask.Resample(image.Width, image.Height);
|
||||
ExposureProcessor.ApplyRegion(image, fitted.Sky, skyEv, landEv, gains, softClipKnee);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
namespace Titano.Core.Analysis;
|
||||
|
||||
public enum RegionMethod
|
||||
{
|
||||
/// <summary>Sky above a per-column horizon line.</summary>
|
||||
Horizon,
|
||||
|
||||
/// <summary>Sky = the brighter class of a luminance threshold.</summary>
|
||||
Luminance,
|
||||
}
|
||||
|
||||
/// <summary>Soft sky/land segmentation: per-pixel sky weight in [0, 1] with a feathered transition.</summary>
|
||||
public sealed class RegionMask
|
||||
{
|
||||
private float[]? _land;
|
||||
|
||||
public RegionMask(int width, int height, float[] sky, double[]? horizon, RegionMethod method, double confidence)
|
||||
{
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(width);
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(height);
|
||||
ArgumentNullException.ThrowIfNull(sky);
|
||||
if (sky.Length != width * height) throw new ArgumentException("One weight per pixel required.", nameof(sky));
|
||||
if (horizon is not null && horizon.Length != width) throw new ArgumentException("One horizon row per column required.", nameof(horizon));
|
||||
Width = width;
|
||||
Height = height;
|
||||
Sky = sky;
|
||||
Horizon = horizon;
|
||||
Method = method;
|
||||
Confidence = confidence;
|
||||
}
|
||||
|
||||
public int Width { get; }
|
||||
public int Height { get; }
|
||||
|
||||
/// <summary>Sky weight per pixel, row-major (1 = sky, 0 = land).</summary>
|
||||
public float[] Sky { get; }
|
||||
|
||||
/// <summary>Land weight per pixel (1 − sky).</summary>
|
||||
public float[] Land
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_land is not null) return _land;
|
||||
var land = new float[Sky.Length];
|
||||
for (var i = 0; i < land.Length; i++) land[i] = 1 - Sky[i];
|
||||
return _land = land;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Horizon position per column in rows from the top edge (horizon method only).</summary>
|
||||
public double[]? Horizon { get; }
|
||||
|
||||
public RegionMethod Method { get; }
|
||||
|
||||
/// <summary>0 … 1; region deflicker is advisable only when this is high.</summary>
|
||||
public double Confidence { get; }
|
||||
|
||||
/// <summary>Bilinear resampling to another resolution (e.g. analysis size → render size), pixel-centre aligned.</summary>
|
||||
public RegionMask Resample(int width, int height)
|
||||
{
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(width);
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(height);
|
||||
if (width == Width && height == Height) return this;
|
||||
var sky = new float[width * height];
|
||||
var sx = (double)Width / width;
|
||||
var sy = (double)Height / height;
|
||||
Parallel.For(0, height, y =>
|
||||
{
|
||||
var fy = Math.Clamp((y + 0.5) * sy - 0.5, 0, Height - 1);
|
||||
var y0 = (int)fy;
|
||||
var y1 = Math.Min(y0 + 1, Height - 1);
|
||||
var ty = (float)(fy - y0);
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var fx = Math.Clamp((x + 0.5) * sx - 0.5, 0, Width - 1);
|
||||
var x0 = (int)fx;
|
||||
var x1 = Math.Min(x0 + 1, Width - 1);
|
||||
var tx = (float)(fx - x0);
|
||||
var top = Sky[y0 * Width + x0] + (Sky[y0 * Width + x1] - Sky[y0 * Width + x0]) * tx;
|
||||
var bottom = Sky[y1 * Width + x0] + (Sky[y1 * Width + x1] - Sky[y1 * Width + x0]) * tx;
|
||||
sky[y * width + x] = top + (bottom - top) * ty;
|
||||
}
|
||||
});
|
||||
double[]? horizon = null;
|
||||
if (Horizon is not null)
|
||||
{
|
||||
horizon = new double[width];
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var fx = Math.Clamp((x + 0.5) * sx - 0.5, 0, Width - 1);
|
||||
var x0 = (int)fx;
|
||||
var x1 = Math.Min(x0 + 1, Width - 1);
|
||||
horizon[x] = (Horizon[x0] + (Horizon[x1] - Horizon[x0]) * (fx - x0)) / sy;
|
||||
}
|
||||
}
|
||||
return new RegionMask(width, height, sky, horizon, Method, Confidence);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,370 @@
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Core.Mathematics;
|
||||
|
||||
namespace Titano.Core.Analysis;
|
||||
|
||||
/// <summary>Parameters of <see cref="RegionSegmenter"/>.</summary>
|
||||
public sealed record RegionSegmenterOptions
|
||||
{
|
||||
public static RegionSegmenterOptions Default { get; } = new();
|
||||
|
||||
/// <summary>Frames sampled evenly from the sequence.</summary>
|
||||
public int MaxFrames { get; init; } = 15;
|
||||
|
||||
/// <summary>Below this the luminance fallback is tried and the more confident mask wins.</summary>
|
||||
public double MinimumHorizonConfidence { get; init; } = 0.4;
|
||||
|
||||
/// <summary>Row-step amplitude in EV that counts as a fully convincing horizon.</summary>
|
||||
public double StrongStepEv { get; init; } = 0.5;
|
||||
|
||||
/// <summary>Width of the feathered transition as a fraction of the image height.</summary>
|
||||
public double FeatherFraction { get; init; } = 0.03;
|
||||
|
||||
/// <summary>Path penalty per row of vertical movement between adjacent columns, relative to the horizon step.</summary>
|
||||
public double SmoothnessPenalty { get; init; } = 0.05;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sky/land segmentation for region deflicker (BRIEF §10.2, §11.2). Horizon: the strongest step of the
|
||||
/// column-averaged log-luminance profile (median over frames, so robust to day/night polarity changes), refined per
|
||||
/// column by a dynamic-programming path that maximises the local step with a smoothness penalty, then feathered.
|
||||
/// Fallback: Otsu threshold of the temporal-median log luminance (brighter class = sky) cleaned by morphological
|
||||
/// opening and closing. Each method reports a confidence in [0, 1].
|
||||
/// </summary>
|
||||
public static class RegionSegmenter
|
||||
{
|
||||
private const float LogFloor = -14;
|
||||
|
||||
public static RegionMask Segment(IReadOnlyList<ImageBuffer> frames, RegionSegmenterOptions? options = null)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(frames);
|
||||
options ??= RegionSegmenterOptions.Default;
|
||||
if (frames.Count == 0) throw new ArgumentException("At least one frame is required.", nameof(frames));
|
||||
var width = frames[0].Width;
|
||||
var height = frames[0].Height;
|
||||
foreach (var f in frames)
|
||||
{
|
||||
if (f.Width != width || f.Height != height) throw new ArgumentException("Frames must share one size.", nameof(frames));
|
||||
}
|
||||
if (height < 8) throw new ArgumentException("Frames must be at least 8 rows tall.", nameof(frames));
|
||||
|
||||
var count = Math.Min(Math.Max(1, options.MaxFrames), frames.Count);
|
||||
var logs = new float[count][];
|
||||
Parallel.For(0, count, i => logs[i] = LogLuminance(frames[(int)((long)i * (frames.Count - 1) / Math.Max(1, count - 1))]));
|
||||
var feather = Math.Max(1.5, options.FeatherFraction * height);
|
||||
|
||||
var (horizon, horizonConfidence) = DetectHorizon(logs, width, height, options);
|
||||
if (horizon is not null && horizonConfidence >= options.MinimumHorizonConfidence)
|
||||
return new RegionMask(width, height, HorizonWeights(horizon, width, height, feather), horizon, RegionMethod.Horizon, horizonConfidence);
|
||||
|
||||
var (sky, luminanceConfidence) = LuminanceWeights(logs, width, height, feather);
|
||||
if (horizon is not null && horizonConfidence >= luminanceConfidence)
|
||||
return new RegionMask(width, height, HorizonWeights(horizon, width, height, feather), horizon, RegionMethod.Horizon, horizonConfidence);
|
||||
return new RegionMask(width, height, sky, null, RegionMethod.Luminance, luminanceConfidence);
|
||||
}
|
||||
|
||||
private static float[] LogLuminance(ImageBuffer image)
|
||||
{
|
||||
var y = new float[image.PlaneLength];
|
||||
ColorSpace.Luminance(image, y);
|
||||
for (var i = 0; i < y.Length; i++) y[i] = y[i] > 6.1035156e-05f ? MathF.Log2(y[i]) : LogFloor;
|
||||
return y;
|
||||
}
|
||||
|
||||
private static (double[]? Horizon, double Confidence) DetectHorizon(float[][] logs, int width, int height, RegionSegmenterOptions options)
|
||||
{
|
||||
var frames = logs.Length;
|
||||
var k = Math.Max(2, height / 24);
|
||||
var steps = new float[frames][];
|
||||
var profiles = new double[frames][];
|
||||
Parallel.For(0, frames, f => (steps[f], profiles[f]) = ColumnSteps(logs[f], width, height, k));
|
||||
|
||||
var score = new double[height];
|
||||
var column = new double[frames];
|
||||
for (var y = k; y <= height - k; y++)
|
||||
{
|
||||
for (var f = 0; f < frames; f++) column[f] = Math.Abs(profiles[f][y]);
|
||||
score[y] = Statistics.MedianInPlace(column);
|
||||
}
|
||||
var y0 = k;
|
||||
for (var y = k; y <= height - k; y++)
|
||||
{
|
||||
if (score[y] > score[y0]) y0 = y;
|
||||
}
|
||||
var peak = score[y0];
|
||||
if (!(peak > 1e-6)) return (null, 0);
|
||||
|
||||
double second = 0;
|
||||
for (var y = k; y <= height - k; y++)
|
||||
{
|
||||
if (Math.Abs(y - y0) > 2 * k) second = Math.Max(second, score[y]);
|
||||
}
|
||||
var consistent = 0;
|
||||
var signs = new int[frames];
|
||||
for (var f = 0; f < frames; f++)
|
||||
{
|
||||
var best = k;
|
||||
for (var y = k; y <= height - k; y++)
|
||||
{
|
||||
if (Math.Abs(profiles[f][y]) > Math.Abs(profiles[f][best])) best = y;
|
||||
}
|
||||
if (Math.Abs(best - y0) <= k) consistent++;
|
||||
signs[f] = profiles[f][y0] < 0 ? -1 : 1;
|
||||
}
|
||||
var confidence = Math.Min(1, peak / options.StrongStepEv) * (1 - second / peak) * consistent / frames;
|
||||
|
||||
// Per-column refinement: minimum-cost path through −(signed local step), median over frames.
|
||||
var band = Math.Max(2 * k, height / 4);
|
||||
var yLo = Math.Max(k, y0 - band);
|
||||
var yHi = Math.Min(height - k, y0 + band);
|
||||
var rows = yHi - yLo + 1;
|
||||
var cost = new double[width * rows];
|
||||
Parallel.For(0, width, x =>
|
||||
{
|
||||
var values = new double[frames];
|
||||
for (var j = 0; j < rows; j++)
|
||||
{
|
||||
var i = (yLo + j) * width + x;
|
||||
for (var f = 0; f < frames; f++) values[f] = signs[f] * steps[f][i];
|
||||
cost[x * rows + j] = -Statistics.MedianInPlace(values);
|
||||
}
|
||||
});
|
||||
var path = MinimumPath(cost, width, rows, Math.Max(2, height / 48), options.SmoothnessPenalty * peak);
|
||||
|
||||
var horizon = new double[width];
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var j = path[x];
|
||||
var offset = 0.0;
|
||||
if (j > 0 && j < rows - 1)
|
||||
{
|
||||
double a = cost[x * rows + j - 1], c = cost[x * rows + j], b = cost[x * rows + j + 1];
|
||||
var curvature = a - 2 * c + b;
|
||||
if (curvature > 0) offset = Math.Clamp(0.5 * (a - b) / curvature, -0.5, 0.5);
|
||||
}
|
||||
horizon[x] = yLo + j + offset;
|
||||
}
|
||||
return (horizon, Math.Clamp(confidence, 0, 1));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Vertical box-difference step (mean of k rows above minus k rows below each row boundary) on a horizontally
|
||||
/// box-smoothed log image, plus its column average.
|
||||
/// </summary>
|
||||
private static (float[] Steps, double[] Profile) ColumnSteps(float[] log, int width, int height, int k)
|
||||
{
|
||||
var radius = Math.Max(1, width / 64);
|
||||
var smooth = new float[log.Length];
|
||||
var prefix = new double[width + 1];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
var row = y * width;
|
||||
for (var x = 0; x < width; x++) prefix[x + 1] = prefix[x] + log[row + x];
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var a = Math.Max(0, x - radius);
|
||||
var b = Math.Min(width, x + radius + 1);
|
||||
smooth[row + x] = (float)((prefix[b] - prefix[a]) / (b - a));
|
||||
}
|
||||
}
|
||||
|
||||
var steps = new float[log.Length];
|
||||
var profile = new double[height];
|
||||
var columnPrefix = new double[height + 1];
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
for (var y = 0; y < height; y++) columnPrefix[y + 1] = columnPrefix[y] + smooth[y * width + x];
|
||||
for (var y = k; y <= height - k; y++)
|
||||
{
|
||||
var above = columnPrefix[y] - columnPrefix[y - k];
|
||||
var below = columnPrefix[y + k] - columnPrefix[y];
|
||||
var step = (above - below) / k;
|
||||
steps[y * width + x] = (float)step;
|
||||
profile[y] += step;
|
||||
}
|
||||
}
|
||||
for (var y = 0; y < height; y++) profile[y] /= width;
|
||||
return (steps, profile);
|
||||
}
|
||||
|
||||
/// <summary>Dynamic programming over columns: each step may move at most <paramref name="slope"/> rows at a
|
||||
/// cost of <paramref name="penalty"/> per row. Returns the row index (within the band) per column.</summary>
|
||||
private static int[] MinimumPath(double[] cost, int width, int rows, int slope, double penalty)
|
||||
{
|
||||
var energy = new double[width * rows];
|
||||
var from = new int[width * rows];
|
||||
Array.Copy(cost, energy, rows);
|
||||
for (var x = 1; x < width; x++)
|
||||
{
|
||||
for (var j = 0; j < rows; j++)
|
||||
{
|
||||
var best = double.PositiveInfinity;
|
||||
var arg = j;
|
||||
for (var d = -slope; d <= slope; d++)
|
||||
{
|
||||
var p = j + d;
|
||||
if (p < 0 || p >= rows) continue;
|
||||
var e = energy[(x - 1) * rows + p] + penalty * Math.Abs(d);
|
||||
if (e < best)
|
||||
{
|
||||
best = e;
|
||||
arg = p;
|
||||
}
|
||||
}
|
||||
energy[x * rows + j] = cost[x * rows + j] + best;
|
||||
from[x * rows + j] = arg;
|
||||
}
|
||||
}
|
||||
var path = new int[width];
|
||||
var end = 0;
|
||||
for (var j = 1; j < rows; j++)
|
||||
{
|
||||
if (energy[(width - 1) * rows + j] < energy[(width - 1) * rows + end]) end = j;
|
||||
}
|
||||
path[width - 1] = end;
|
||||
for (var x = width - 1; x > 0; x--) path[x - 1] = from[x * rows + path[x]];
|
||||
return path;
|
||||
}
|
||||
|
||||
private static float[] HorizonWeights(double[] horizon, int width, int height, double feather)
|
||||
{
|
||||
var sky = new float[width * height];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var t = Math.Clamp(0.5 + (horizon[x] - (y + 0.5)) / feather, 0, 1);
|
||||
sky[y * width + x] = (float)(t * t * (3 - 2 * t));
|
||||
}
|
||||
}
|
||||
return sky;
|
||||
}
|
||||
|
||||
private static (float[] Sky, double Confidence) LuminanceWeights(float[][] logs, int width, int height, double feather)
|
||||
{
|
||||
var n = width * height;
|
||||
var median = new double[n];
|
||||
var values = new double[logs.Length];
|
||||
for (var i = 0; i < n; i++)
|
||||
{
|
||||
for (var f = 0; f < logs.Length; f++) values[f] = logs[f][i];
|
||||
median[i] = Statistics.MedianInPlace(values);
|
||||
}
|
||||
|
||||
double min = double.PositiveInfinity, max = double.NegativeInfinity;
|
||||
foreach (var v in median)
|
||||
{
|
||||
min = Math.Min(min, v);
|
||||
max = Math.Max(max, v);
|
||||
}
|
||||
if (!(max - min > 1e-6)) return (new float[n], 0);
|
||||
|
||||
var (threshold, separability) = Otsu(median, min, max);
|
||||
var binary = new byte[n];
|
||||
for (var i = 0; i < n; i++) binary[i] = median[i] > threshold ? (byte)1 : (byte)0;
|
||||
var radius = Math.Max(1, Math.Min(width, height) / 64);
|
||||
binary = MinMax(MinMax(binary, width, height, radius, dilate: false), width, height, radius, dilate: true);
|
||||
binary = MinMax(MinMax(binary, width, height, radius, dilate: true), width, height, radius, dilate: false);
|
||||
|
||||
var sky = new float[n];
|
||||
for (var i = 0; i < n; i++) sky[i] = binary[i];
|
||||
BoxBlur(sky, width, height, Math.Max(1, (int)Math.Round(feather / 2)));
|
||||
// Otsu's η is 2/π for a single Gaussian mode: rescale so a unimodal image scores 0 and two spikes score 1.
|
||||
var confidence = Math.Clamp((separability - 2 / Math.PI) / (1 - 2 / Math.PI), 0, 1);
|
||||
return (sky, confidence);
|
||||
}
|
||||
|
||||
/// <summary>Otsu (1979) threshold over a 256-bin histogram and its separability η = σ²between / σ²total.</summary>
|
||||
private static (double Threshold, double Separability) Otsu(double[] values, double min, double max)
|
||||
{
|
||||
const int bins = 256;
|
||||
var histogram = new double[bins];
|
||||
Statistics.AccumulateHistogram(values, min, max + (max - min) * 1e-9, histogram);
|
||||
var width = (max - min) / bins;
|
||||
double total = values.Length, sumAll = 0, sumSquares = 0;
|
||||
for (var i = 0; i < bins; i++)
|
||||
{
|
||||
var centre = min + (i + 0.5) * width;
|
||||
sumAll += histogram[i] * centre;
|
||||
sumSquares += histogram[i] * centre * centre;
|
||||
}
|
||||
var mean = sumAll / total;
|
||||
var variance = sumSquares / total - mean * mean;
|
||||
double w0 = 0, sum0 = 0, bestBetween = -1;
|
||||
var bestBin = 0;
|
||||
for (var i = 0; i < bins - 1; i++)
|
||||
{
|
||||
w0 += histogram[i];
|
||||
sum0 += histogram[i] * (min + (i + 0.5) * width);
|
||||
var w1 = total - w0;
|
||||
if (w0 <= 0 || w1 <= 0) continue;
|
||||
var m0 = sum0 / w0;
|
||||
var m1 = (sumAll - sum0) / w1;
|
||||
var between = w0 * w1 * (m0 - m1) * (m0 - m1) / (total * total);
|
||||
if (between > bestBetween)
|
||||
{
|
||||
bestBetween = between;
|
||||
bestBin = i;
|
||||
}
|
||||
}
|
||||
return (min + (bestBin + 1) * width, variance > 0 ? Math.Max(0, bestBetween) / variance : 0);
|
||||
}
|
||||
|
||||
/// <summary>Binary erosion (min) or dilation (max) with a (2r+1)² square, as two separable passes.</summary>
|
||||
private static byte[] MinMax(byte[] source, int width, int height, int radius, bool dilate)
|
||||
{
|
||||
var horizontal = new byte[source.Length];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var v = dilate ? (byte)0 : (byte)1;
|
||||
for (var d = -radius; d <= radius; d++)
|
||||
{
|
||||
var s = source[y * width + Math.Clamp(x + d, 0, width - 1)];
|
||||
v = dilate ? Math.Max(v, s) : Math.Min(v, s);
|
||||
}
|
||||
horizontal[y * width + x] = v;
|
||||
}
|
||||
}
|
||||
var result = new byte[source.Length];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
var v = dilate ? (byte)0 : (byte)1;
|
||||
for (var d = -radius; d <= radius; d++)
|
||||
{
|
||||
var s = horizontal[Math.Clamp(y + d, 0, height - 1) * width + x];
|
||||
v = dilate ? Math.Max(v, s) : Math.Min(v, s);
|
||||
}
|
||||
result[y * width + x] = v;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Separable box blur with edge-shrunk windows, in place.</summary>
|
||||
private static void BoxBlur(float[] data, int width, int height, int radius)
|
||||
{
|
||||
var line = new double[Math.Max(width, height) + 1];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
for (var x = 0; x < width; x++) line[x + 1] = line[x] + data[y * width + x];
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
int a = Math.Max(0, x - radius), b = Math.Min(width, x + radius + 1);
|
||||
data[y * width + x] = (float)((line[b] - line[a]) / (b - a));
|
||||
}
|
||||
}
|
||||
for (var x = 0; x < width; x++)
|
||||
{
|
||||
for (var y = 0; y < height; y++) line[y + 1] = line[y] + data[y * width + x];
|
||||
for (var y = 0; y < height; y++)
|
||||
{
|
||||
int a = Math.Max(0, y - radius), b = Math.Min(height, y + radius + 1);
|
||||
data[y * width + x] = (float)((line[b] - line[a]) / (b - a));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,201 @@
|
||||
using System.Globalization;
|
||||
using Titano.Core.Analysis;
|
||||
using Titano.Core.Diagnostics.Synthetic;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.Core.Tests.Analysis;
|
||||
|
||||
public sealed class RegionTests(TestContext context)
|
||||
{
|
||||
private static SyntheticSequence Landscape(int frames, double tilt, double wave, int seed = 5) => SyntheticSequence.Create(new SyntheticSequenceOptions
|
||||
{
|
||||
Width = 128,
|
||||
Height = 80,
|
||||
FrameCount = frames,
|
||||
Seed = seed,
|
||||
StartEv = -1,
|
||||
EndEv = 0,
|
||||
HorizonFraction = 0.45,
|
||||
HorizonTilt = tilt,
|
||||
HorizonWave = wave,
|
||||
SkyFlickerEv = 0.15,
|
||||
LandFlickerEv = 0.15,
|
||||
});
|
||||
|
||||
private static List<ImageBuffer> RenderAll(SyntheticSequence sequence) => Enumerable.Range(0, sequence.Count).Select(sequence.Render).ToList();
|
||||
|
||||
[Test]
|
||||
public void HorizonIsFoundPerColumnWithHighConfidence()
|
||||
{
|
||||
var sequence = Landscape(30, tilt: 0.08, wave: 3);
|
||||
var frames = RenderAll(sequence);
|
||||
try
|
||||
{
|
||||
var mask = RegionSegmenter.Segment(frames);
|
||||
Assert.Equal(RegionMethod.Horizon, mask.Method);
|
||||
Assert.Greater(mask.Confidence, 0.6);
|
||||
var horizon = Assert.NotNull(mask.Horizon);
|
||||
var worst = Enumerable.Range(0, mask.Width).Max(x => Math.Abs(horizon[x] - sequence.HorizonRow(x + 0.5)));
|
||||
var agreement = Agreement(mask, sequence);
|
||||
context.Log(string.Create(CultureInfo.InvariantCulture, $"confidence {mask.Confidence:F3}, worst column error {worst:F3} px, pixel agreement {agreement:P2}"));
|
||||
Assert.LessOrEqual(worst, 1.0);
|
||||
Assert.GreaterOrEqual(agreement, 0.98);
|
||||
}
|
||||
finally
|
||||
{
|
||||
frames.ForEach(f => f.Dispose());
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void HorizonSurvivesPolarityChangesAcrossFrames()
|
||||
{
|
||||
var day = Landscape(10, tilt: 0, wave: 0);
|
||||
var night = SyntheticSequence.Create(day.Options with { SkyLevel = 0.01, LandLevel = 0.2, Seed = 6 });
|
||||
var frames = RenderAll(day).Concat(RenderAll(night)).ToList();
|
||||
try
|
||||
{
|
||||
var mask = RegionSegmenter.Segment(frames);
|
||||
Assert.Equal(RegionMethod.Horizon, mask.Method);
|
||||
var horizon = Assert.NotNull(mask.Horizon);
|
||||
Assert.True(horizon.All(h => Math.Abs(h - 0.45 * 80) <= 1), "horizon row");
|
||||
}
|
||||
finally
|
||||
{
|
||||
frames.ForEach(f => f.Dispose());
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CliffFallsBackToLuminance()
|
||||
{
|
||||
// Sky above row 20 on the left half and above row 60 on the right: no single row step explains it.
|
||||
var frames = new List<ImageBuffer>();
|
||||
for (var f = 0; f < 6; f++)
|
||||
{
|
||||
var image = new ImageBuffer(96, 80, 3);
|
||||
for (var y = 0; y < 80; y++)
|
||||
{
|
||||
for (var x = 0; x < 96; x++)
|
||||
{
|
||||
var sky = y < (x < 48 ? 20 : 60);
|
||||
var v = sky ? 0.4f * (1 + 0.02f * f) : 0.03f * (1 + ((x * 7 + y * 13) % 5) * 0.1f);
|
||||
for (var c = 0; c < 3; c++) image[c, x, y] = v;
|
||||
}
|
||||
}
|
||||
frames.Add(image);
|
||||
}
|
||||
try
|
||||
{
|
||||
var mask = RegionSegmenter.Segment(frames);
|
||||
Assert.Equal(RegionMethod.Luminance, mask.Method);
|
||||
Assert.Greater(mask.Confidence, 0.5);
|
||||
var correct = 0;
|
||||
for (var y = 0; y < 80; y++)
|
||||
{
|
||||
for (var x = 0; x < 96; x++)
|
||||
{
|
||||
var sky = y < (x < 48 ? 20 : 60);
|
||||
if (mask.Sky[y * 96 + x] >= 0.5f == sky) correct++;
|
||||
}
|
||||
}
|
||||
Assert.GreaterOrEqual(correct / (96.0 * 80), 0.97);
|
||||
}
|
||||
finally
|
||||
{
|
||||
frames.ForEach(f => f.Dispose());
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FeaturelessFramesHaveNoConfidence()
|
||||
{
|
||||
using var flat = new ImageBuffer(64, 48, 3);
|
||||
flat.Data.Fill(0.2f);
|
||||
var mask = RegionSegmenter.Segment([flat]);
|
||||
Assert.Less(mask.Confidence, 0.05);
|
||||
}
|
||||
|
||||
/// <summary>BRIEF §20.4: with independent sky and land flicker, the land residual after region deflicker is at
|
||||
/// most 25 % of the residual left by one global curve.</summary>
|
||||
[Test]
|
||||
public void RegionDeflickerMeetsTheRegressionGate()
|
||||
{
|
||||
var sequence = Landscape(150, tilt: 0.05, wave: 2);
|
||||
var frames = RenderAll(sequence);
|
||||
RegionMask mask;
|
||||
double[] sky, land, global;
|
||||
try
|
||||
{
|
||||
mask = RegionSegmenter.Segment(frames);
|
||||
sky = new double[frames.Count];
|
||||
land = new double[frames.Count];
|
||||
global = new double[frames.Count];
|
||||
for (var i = 0; i < frames.Count; i++)
|
||||
{
|
||||
(sky[i], land[i]) = RegionDeflicker.Measure(frames[i], mask);
|
||||
global[i] = FrameStatistics.MeasureLogLuminance(frames[i]);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
frames.ForEach(f => f.Dispose());
|
||||
}
|
||||
|
||||
var options = new DeflickerOptions { Window = 31 };
|
||||
var globalResult = DeflickerEngine.Compute(global, options);
|
||||
var regionResult = RegionDeflicker.Compute(sky, land, options);
|
||||
var trueLand = AnalysisFixtures.TrueLandMask(sequence);
|
||||
var landAfterGlobal = AnalysisFixtures.MeasureSeries(sequence, (i, image) =>
|
||||
{
|
||||
ExposureProcessor.Apply(image, globalResult.CorrectionEv[i]);
|
||||
return image;
|
||||
}, trueLand);
|
||||
var landAfterRegion = AnalysisFixtures.MeasureSeries(sequence, (i, image) =>
|
||||
{
|
||||
RegionDeflicker.Apply(image, mask, regionResult.Sky.CorrectionEv[i], regionResult.Land.CorrectionEv[i]);
|
||||
return image;
|
||||
}, trueLand);
|
||||
|
||||
var globalResidual = AnalysisFixtures.FrameToFrameResidualRms(landAfterGlobal, sequence.SceneEv);
|
||||
var regionResidual = AnalysisFixtures.FrameToFrameResidualRms(landAfterRegion, sequence.SceneEv);
|
||||
var ratio = regionResidual / globalResidual;
|
||||
context.Log(string.Create(CultureInfo.InvariantCulture,
|
||||
$"mask {mask.Method} confidence {mask.Confidence:F3}; land residual global {globalResidual:F4} EV, region {regionResidual:F4} EV, ratio {ratio:P1}"));
|
||||
Assert.LessOrEqual(ratio, 0.25);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ResampledMaskKeepsTheHorizon()
|
||||
{
|
||||
var sequence = Landscape(6, tilt: 0, wave: 0);
|
||||
var frames = RenderAll(sequence);
|
||||
try
|
||||
{
|
||||
var mask = RegionSegmenter.Segment(frames);
|
||||
var big = mask.Resample(256, 160);
|
||||
Assert.Equal(256 * 160, big.Sky.Length);
|
||||
Assert.Approximately(2 * mask.Horizon![10], big.Horizon![20], 0.6);
|
||||
Assert.True(big.Sky[5 * 256 + 100] > 0.99f && big.Sky[150 * 256 + 100] < 0.01f);
|
||||
Assert.Same(mask, mask.Resample(mask.Width, mask.Height));
|
||||
}
|
||||
finally
|
||||
{
|
||||
frames.ForEach(f => f.Dispose());
|
||||
}
|
||||
}
|
||||
|
||||
private static double Agreement(RegionMask mask, SyntheticSequence sequence)
|
||||
{
|
||||
var correct = 0;
|
||||
for (var y = 0; y < mask.Height; y++)
|
||||
{
|
||||
for (var x = 0; x < mask.Width; x++)
|
||||
{
|
||||
if (mask.Sky[y * mask.Width + x] >= 0.5f == sequence.IsSky(x, y)) correct++;
|
||||
}
|
||||
}
|
||||
return correct / (double)(mask.Width * mask.Height);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user