Files
Alby96andClaude Opus 5.5 efa87f68ce
CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
feat: owner review 2 phase 4b: mass conversion after import (#13)
Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-11-03 10:41:50 +01:00

292 lines
17 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using Chronos.Core.Codecs.Icc;
using Chronos.Core.Codecs.Tiff;
using Chronos.Core.Conversion;
using Chronos.Core.Imaging;
using Chronos.Core.Mathematics;
using Chronos.Core.Tests.Conversion;
using Chronos.Testing;
namespace Chronos.Core.Tests.Codecs;
/// <summary>ICC profiles (owner review 2, R7): parsed, synthesized for the spaces a marker names, and read from each container.</summary>
public sealed class IccProfileTests(TestContext context)
{
[Test]
public void TheSynthesizedProfilesAreMatrixShapersOfTheirSpace()
{
var adobe = IccProfile.AdobeRgb;
Assert.True(adobe.IsMatrixShaper && adobe.IsRgb && !adobe.IsSrgb);
Assert.Equal("Compatible with Adobe RGB (1998)", adobe.Description);
// Colorants add up to the D50 PCS white.
var white = adobe.Colorants!.Value * new Vector3D(1, 1, 1);
Assert.Approximately(0.9642, white.X, 2e-4);
Assert.Approximately(1.0, white.Y, 2e-4);
Assert.Approximately(0.8249, white.Z, 2e-4);
// Adobe RGB → linear sRGB: red reaches 1.398 with green −0.398, blue stays put but borrows from green.
var m = adobe.ToLinearRec709();
Assert.Approximately(1.3982, m.M11, 2e-3);
Assert.Approximately(-0.3982, m.M12, 2e-3);
Assert.Approximately(1.0, m.M22, 2e-3);
Assert.Approximately(-0.0429, m.M32, 2e-3);
Assert.Approximately(1.0429, m.M33, 2e-3);
var neutral = m * new Vector3D(1, 1, 1);
Assert.Approximately(1, neutral.X, 1e-9);
Assert.Approximately(1, neutral.Y, 1e-9);
Assert.Approximately(1, neutral.Z, 1e-9);
// Its gamma 563/256, written as a u8Fixed8 curve.
Assert.Approximately(Math.Pow(0.5, 563 / 256.0), adobe.Curves![0].Evaluate(0.5), 1e-12);
var p3 = IccProfile.DisplayP3;
Assert.True(p3.IsMatrixShaper);
// The sRGB curve, tabulated in 1024 entries.
for (var v = 0.0; v <= 1; v += 0.05) Assert.Approximately(ColorSpace.SrgbToLinear(v), p3.Curves![1].Evaluate(v), 2e-5);
// P3's own green is outside sRGB: negative red and blue in Rec.709.
var green = p3.ToLinearRec709() * new Vector3D(0, 1, 0);
Assert.Approximately(-0.2246, green.X, 3e-3);
Assert.Approximately(1.0421, green.Y, 3e-3);
Assert.Approximately(-0.0786, green.Z, 3e-3);
Assert.Null(IccProfile.Parse(new byte[200]));
Assert.Null(IccProfile.Parse(adobe.Data[..131]));
}
[Test]
public void ParametricCurvesFollowTheirFunctions()
{
// para function 3 with the sRGB parameters (as Apple's Display P3 profile writes it).
byte[] tag = [.. "para"u8, 0, 0, 0, 0, 0, 3, 0, 0, .. Fixed(2.4), .. Fixed(1 / 1.055), .. Fixed(0.055 / 1.055), .. Fixed(1 / 12.92), .. Fixed(0.04045)];
var curve = IccCurve.Parse(tag)!;
foreach (var v in new[] { 0.0, 0.02, 0.04045, 0.3, 0.75, 1.0 }) Assert.Approximately(ColorSpace.SrgbToLinear(v), curve.Evaluate(v), 2e-5);
Assert.Approximately(Math.Pow(0.5, 1.8), IccCurve.Parse([.. "para"u8, 0, 0, 0, 0, 0, 0, 0, 0, .. Fixed(1.8)])!.Evaluate(0.5), 1e-4);
Assert.Approximately(0.25, IccCurve.Parse([.. "curv"u8, 0, 0, 0, 0, 0, 0, 0, 0])!.Evaluate(0.25), 1e-12);
Assert.Approximately(0.5, IccCurve.Parse([.. "curv"u8, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0x80, 0, 0xFF, 0xFF])!.Evaluate(0.5), 1e-4);
Assert.Null(IccCurve.Parse([.. "para"u8, 0, 0, 0, 0, 0, 9, 0, 0]));
static byte[] Fixed(double v)
{
var b = new byte[4];
System.Buffers.Binary.BinaryPrimitives.WriteInt32BigEndian(b, (int)Math.Round(v * 65536));
return b;
}
}
/// <summary>
/// Colorants that convert nothing (their white has a cone response that is not positive, as a damaged profile's may) are
/// dropped when the profile is parsed: it stays an RGB profile to carry, never one to convert through, and asking its
/// matrix fails as for any profile without one, not inside the chromatic adaptation.
/// </summary>
[Test]
public void ColorantsThatConvertNothingAreDroppedWhenParsed()
{
var degenerate = IccProfile.Parse(ColorFixtures.Degenerate())!;
Assert.True(degenerate.IsRgb);
Assert.Null(degenerate.Colorants);
Assert.False(degenerate.IsMatrixShaper);
Assert.False(degenerate.IsSrgb);
Assert.Throws<InvalidOperationException>(() => degenerate.ToLinearRec709());
// The same colorants inside a white with positive cone responses convert.
Assert.NotNull(IccProfile.AdobeRgb.Colorants);
}
/// <summary>
/// A damaged profile never fails a conversion's colour work midway (owner review 2, R7): bytes flipped in matrix/TRC
/// profiles, as in a damaged file, give a profile that does not parse, one only to carry, or one whose matrix is finite
/// and invertible; wherever the treatment asks for a profile made for the codes written (a float TIFF's linear values
/// into a JPEG or TIFF), that profile is made and parses, its matrix finite and invertible; a DNG takes the values as
/// they are or refuses them. Anything else the treatment refuses before any pixel is decoded.
/// </summary>
[Test]
public void DamagedProfilesConvertOrAreRefusedNeverFailMidway()
{
var random = new Random(27);
using var pixels = new ImageBuffer(4, 2);
float[] values = [0, 0.18f, 0.5f, 1, 3, -0.2f, 0.02f, 0.9f];
var data = pixels.Data;
for (var i = 0; i < data.Length; i++) data[i] = values[i % values.Length];
int parsed = 0, described = 0;
foreach (var original in (byte[][])[IccProfile.AdobeRgb.Data, IccProfile.DisplayP3.Data, ColorFixtures.Profile("Wide gamma 1.8", IccCurve.Gamma(1.8), wide: true).Data])
{
for (var n = 0; n < 1000; n++)
{
var damaged = (byte[])original.Clone();
// The tag table and the tags: colorants, curves, description.
for (var k = random.Next(1, 4); k > 0; k--) damaged[random.Next(128, damaged.Length)] ^= (byte)random.Next(1, 256);
if (IccProfile.Parse(damaged) is not { } profile) continue;
parsed++;
if (profile.IsMatrixShaper)
{
var m = profile.ToLinearRec709();
Assert.True(Finite(m) && m.TryInvert(out var inverse) && Finite(inverse), "a matrix to convert through is finite and invertible");
}
SourceColor[] carriers =
[
SourceColor.Read(new MemoryStream(JpegCarrying(damaged)), ImageFileFormat.Jpeg),
SourceColor.Read(new MemoryStream(ColorFixtures.FloatTiff(pixels, damaged)), ImageFileFormat.Tiff),
];
foreach (var color in carriers)
{
foreach (var target in Enum.GetValues<ConvertTarget>())
{
var treatment = FrameConverter.Treatment(color, target);
if (target == ConvertTarget.LinearDng) Assert.True(treatment is ColorTreatment.None or ColorTreatment.Refuse, $"a DNG of {treatment}");
if (treatment != ColorTreatment.Describe) continue;
var made = IccProfile.Parse(FrameConverter.Described(color.Profile!).Data);
Assert.True(made is { IsMatrixShaper: true }, "the profile made for the codes parses as a matrix/TRC one");
var m = made!.ToLinearRec709();
Assert.True(Finite(m) && m.TryInvert(out var inverse) && Finite(inverse), "and converts with finite numbers");
described++;
}
}
}
}
context.Log($"{parsed} damaged profiles parsed, {described} described");
Assert.Greater(parsed, 1000);
Assert.Greater(described, 1000);
static bool Finite(Matrix3 m) => new[] { m.M11, m.M12, m.M13, m.M21, m.M22, m.M23, m.M31, m.M32, m.M33 }.All(double.IsFinite);
// The markers of a JPEG carrying the profile in one APP2 chunk, no image: all its colour is read from.
static byte[] JpegCarrying(byte[] icc)
{
var length = 2 + 14 + icc.Length;
return [0xFF, 0xD8, 0xFF, 0xE2, (byte)(length >> 8), (byte)length, .. "ICC_PROFILE\0"u8, 1, 1, .. icc, 0xFF, 0xD9];
}
}
/// <summary>
/// A matrix/TRC profile is sRGB when its numbers are sRGB's, whatever its name says; one without colorant tags at all (a
/// lookup-table profile) by its name. One whose colorants convert nothing, or whose curves are missing, is not, whatever
/// its name (owner review 2, R7).
/// </summary>
[Test]
public void SrgbIsWhatTheNumbersSay()
{
Assert.True(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Srgb).IsSrgb);
Assert.True(ColorFixtures.Profile("Camera RGB", IccCurve.Srgb).IsSrgb);
// sRGB's primaries with a linear curve, or a gamma 2.2 one, named sRGB.
Assert.False(ColorFixtures.Profile("sRGB-elle-V4-g10", IccCurve.Gamma(1)).IsSrgb);
Assert.False(ColorFixtures.Profile("sRGB gamma 2.2", IccCurve.Gamma(2.2)).IsSrgb);
Assert.False(ColorFixtures.Profile("sRGB wide", IccCurve.Srgb, wide: true).IsSrgb);
Assert.False(IccProfile.DisplayP3.IsSrgb);
// Without colorant tags, the name decides; with colorants that convert nothing, or no curves, nothing says sRGB.
Assert.True(IccProfile.Parse(ColorFixtures.WithoutColorants(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Gamma(1)).Data))!.IsSrgb);
Assert.False(IccProfile.Parse(ColorFixtures.WithoutColorants(IccProfile.AdobeRgb.Data))!.IsSrgb);
var degenerate = IccProfile.Parse(ColorFixtures.Degenerate(ColorFixtures.Profile("sRGB-elle-V4-g10", IccCurve.Srgb).Data))!;
Assert.True(degenerate is { IsRgb: true, Colorants: null, IsSrgb: false });
var curveless = ColorFixtures.Renamed(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Srgb).Data, "rTRC", "xTRC");
Assert.True(IccProfile.Parse(curveless) is { IsMatrixShaper: false, IsSrgb: false });
// The curves themselves.
Assert.True(IccCurve.Srgb.IsSrgb && IccProfile.DisplayP3.Curves![0].IsSrgb);
Assert.False(IccCurve.Gamma(2.2).IsSrgb || IccCurve.Gamma(1).IsSrgb);
}
/// <summary>
/// Values are sRGB's as Chronos's decoders take them (owner review 2, R7) when they are in sRGB's primaries and, for code
/// values, through sRGB's curve: a linear-curve profile in sRGB's primaries holds sRGB's linear values but not its code
/// values; a gray profile's linear values are linear gray, its code values need the sRGB curve.
/// </summary>
[Test]
public void ValuesAreSrgbsWhereThePrimariesAndTheCurveSaySo()
{
(IccProfile Profile, bool Linear, bool Codes)[] cases =
[
(ColorFixtures.Profile("sRGB IEC61966-2.1", IccCurve.Srgb), true, true),
(ColorFixtures.Profile("sRGB-elle-V4-g10", IccCurve.Gamma(1)), true, false),
(ColorFixtures.Profile("sRGB gamma 2.2", IccCurve.Gamma(2.2)), true, false),
(IccProfile.AdobeRgb, false, false),
(IccProfile.DisplayP3, false, false),
(ColorFixtures.ProPhoto(), false, false),
(IccProfile.Parse(ColorFixtures.Gray("Gray Gamma 2.2", IccCurve.Gamma(2.2)))!, true, false),
(IccProfile.Parse(ColorFixtures.Gray("sGray", IccCurve.Srgb))!, true, true),
(IccProfile.Parse(ColorFixtures.Cmyk())!, false, false),
(IccProfile.Parse(ColorFixtures.Degenerate())!, false, false),
];
foreach (var (profile, linear, codes) in cases)
Assert.Equal((linear, codes), (profile.IsSrgbFor(linear: true), profile.IsSrgbFor(linear: false)), $"{profile.Description} ({profile.ColorSpace:X8})");
}
/// <summary>
/// The profiles a converted file carries for codes that are not the original's (owner review 2, R7): a matrix/TRC
/// profile's colorants and media white with the sRGB curve, to the bit; a gray profile's curve on three channels whose
/// equal values are neutral.
/// </summary>
[Test]
public void ProfilesMadeForTheCodesKeepWhatTheyDescribe()
{
foreach (var source in (IccProfile[])[IccProfile.AdobeRgb, ColorFixtures.ProPhoto(), ColorFixtures.Profile("Wide gamma 1.0", IccCurve.Gamma(1), wide: true)])
{
var made = IccProfile.Parse(source.WithSrgbCurve().Data)!;
Assert.True(made.IsMatrixShaper && made.IsRgb, source.Description);
Assert.Equal(source.Colorants, made.Colorants);
Assert.Equal(source.MediaWhite, made.MediaWhite);
Assert.True(made.Curves!.All(c => c.IsSrgb), source.Description);
Assert.Equal($"{source.Description} (sRGB curve)", made.Description);
}
var gray = IccProfile.Parse(ColorFixtures.Gray("Gray Gamma 2.2", IccCurve.Gamma(2.2)))!;
var rgb = IccProfile.Parse(gray.GrayAsRgb().Data)!;
Assert.True(rgb is { IsMatrixShaper: true, IsRgb: true });
Assert.Equal("Gray Gamma 2.2 (RGB)", rgb.Description);
for (var code = 0.0; code <= 1; code += 0.125)
{
var light = rgb.ToLinearRec709() * new Vector3D(rgb.Curves![0].Evaluate(code), rgb.Curves[1].Evaluate(code), rgb.Curves[2].Evaluate(code));
var expected = gray.Curves![0].Evaluate(code);
Assert.Approximately(expected, light.X, 1e-3);
Assert.Approximately(expected, light.Y, 1e-3);
Assert.Approximately(expected, light.Z, 1e-3);
}
Assert.Throws<InvalidOperationException>(() => gray.WithSrgbCurve());
Assert.Throws<InvalidOperationException>(() => IccProfile.AdobeRgb.GrayAsRgb());
// A damaged profile's endless description is cut.
var long1 = IccProfile.Synthesize(new string('x', 5000), new(0.64, 0.33), new(0.30, 0.60), new(0.15, 0.06), IccCurve.Srgb);
Assert.Less(long1.Description!.Length, 300);
}
/// <summary>A TIFF of floating-point samples or linear RAW holds linear values; integer samples are code values.</summary>
[Test]
public void ATiffSaysWhetherItsSamplesAreLinear()
{
using var scene = ColorFixtures.Scene();
SourceColor Read(byte[] file) => SourceColor.Read(new MemoryStream(file), ImageFileFormat.Tiff);
var adobe = IccProfile.AdobeRgb.Data;
var linear = Read(ColorFixtures.FloatTiff(scene, adobe));
Assert.True(linear.IsLinear);
Assert.BytesEqual(adobe, linear.Profile!.Data);
Assert.True(Read(ColorFixtures.FloatTiff(scene)) is { IsLinear: true, Profile: null, IsUnknown: false });
Assert.True(Read(Chronos.Core.Codecs.Dng.LinearDngWriter.Write(scene)).IsLinear);
Assert.False(Read(TiffWriter.Write(scene, new TiffWriteOptions { BitsPerSample = 16, IccProfile = adobe })).IsLinear);
Assert.False(Read(TiffWriter.Write(scene)).IsLinear);
}
[Test]
public void EachContainerSaysItsColourSpace()
{
using var scene = ColorFixtures.Scene();
var p3 = IccProfile.DisplayP3.Data;
SourceColor Read(byte[] file, ImageFileFormat format) => SourceColor.Read(new MemoryStream(file), format);
// Untagged and sRGB files are sRGB.
Assert.Same(SourceColor.Untagged, Read(ColorFixtures.Jpeg(scene), ImageFileFormat.Jpeg));
Assert.Same(SourceColor.Untagged, Read(ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(1, "R98")), ImageFileFormat.Jpeg));
// An embedded profile, byte for byte: JPEG APP2 (one chunk, or several), PNG iCCP, TIFF tag 34675, HEIF prof.
Assert.BytesEqual(p3, Read(ColorFixtures.Jpeg(scene, p3), ImageFileFormat.Jpeg).Profile!.Data);
var large = ColorFixtures.Large();
Assert.BytesEqual(large, Read(ColorFixtures.Jpeg(scene, large), ImageFileFormat.Jpeg).Profile!.Data);
Assert.BytesEqual(p3, Read(ColorFixtures.Png(scene, p3), ImageFileFormat.Png).Profile!.Data);
Assert.BytesEqual(p3, Read(TiffWriter.Write(scene, new TiffWriteOptions { IccProfile = p3 }), ImageFileFormat.Tiff).Profile!.Data);
Assert.BytesEqual(p3, Read(ColorFixtures.Heif(ColorFixtures.Nclx(1, 13), ColorFixtures.Prof(p3)), ImageFileFormat.Heif).Profile!.Data);
// A grid whose tiles carry the profile, not the grid item.
Assert.BytesEqual(p3, Read(ColorFixtures.Heif(2, ColorFixtures.Prof(p3)), ImageFileFormat.Heif).Profile!.Data);
// A camera's Adobe RGB marker (uncalibrated, Interop R03) names Adobe RGB, in a JPEG and in a TIFF.
Assert.Same(IccProfile.AdobeRgb, Read(ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF, "R03")), ImageFileFormat.Jpeg).Profile);
// nclx: BT.709 is sRGB, P3 primaries Display P3, BT.2020 or PQ unknown.
Assert.Same(SourceColor.Untagged, Read(ColorFixtures.Heif(ColorFixtures.Nclx(1, 13)), ImageFileFormat.Heif));
Assert.Same(IccProfile.DisplayP3, Read(ColorFixtures.Heif(ColorFixtures.Nclx(12, 13)), ImageFileFormat.Heif).Profile);
Assert.True(Read(ColorFixtures.Heif(ColorFixtures.Nclx(9, 16)), ImageFileFormat.Heif).IsUnknown);
// Uncalibrated without R03, or a profile that does not parse: a space nothing here describes.
Assert.True(Read(ColorFixtures.Jpeg(scene, exifTiff: ColorFixtures.Exif(0xFFFF)), ImageFileFormat.Jpeg).IsUnknown);
Assert.True(Read(ColorFixtures.Jpeg(scene, new byte[300]), ImageFileFormat.Jpeg).IsUnknown);
// RAWs say nothing here: their decoders give Rec.709.
Assert.Same(SourceColor.Untagged, Read([1, 2, 3], ImageFileFormat.Cr2));
}
}