3dtours
224ff0b935
LibRaw's half-size demosaic was on. The Ricoh GR's own DNG (D0004128.DNG) developed to 3010x2012 while the JPEG written beside it in the same second is 6000x4000, and the Fuji's RAF to 3008x2007 against its own 6000x4000 -- the quarter was the flag, not the file. With `halfSize: false` the same develop returns 6020x4024 and it is the sensor's frame on every body tried: D0004128.DNG 6020x4024 IMGP6916.DNG 6028x4024 DSCF1701.RAF 6016x4014 _DSC0009.ARW 6024x4024 AFXT2721.RAF 6246x4170 Nikon-D850 NEF 6216x4136 _GDN0447.NEF 4284x2844 P1010607.RW2 3472x3472 5G4A9396.CR2 2880x1920 Nine files, 27s to 155s a develop on one core. Checked through the app itself, not only through LibRaw: photo-dims 6020x4024 on the DNG against 6000x4000 on the JPEG, both err none. The colour it opens with is now fitted per file to the preview the camera wrote into it (previewMatch.ts): a 3x3 over a block grid of the develop against the same grid of that preview, then one cubic a channel for what the 3x3 leaves. The offline per-body table this replaces (cameraMatch.ts) stopped matching the moment the path under it changed -- its rows no longer summed to 1 once the highlight knee landed ahead of it -- and a body with a row opened with a cast one without did not. The file's own preview does not age. The white level the gain carries is the frame's own plateau rather than `maximum` (sensorWhite.ts), a factor of 1.89 to 2.00 out; without it every frame opened a stop bright and a body that sat lower (X-Trans, 1.892) never reached the highlight desaturation at all. The desaturation gate reads the gain-lifted levels as well as the sensor's, which is the whole of the magenta: on a body whose cam_mul lifts red and blue (the GR's [2.64, 1, 1.73]) a blown sky crosses the white level at 0.38 of the raw range in red while green crosses at 1.0, so a gate read on the sensor's levels alone stayed shut across it. Measured in the app against the camera's own JPEG, mean dRGB over a 16x16 block grid: +1.20, -5.95, -6.11 with the sensor's clip alone, +0.21, +0.24, +0.47 with both, mean |dL| 21.5 against 10.3. The same grid on the Fuji comes back balanced (+4.7, +5.0, +3.6) and best aligned at offset 0,0. -HL is recovery and +HL is a lift, so they are different moves now: recovery is the doc's soft knee in linear light over the top half, which is the only term in the tone shader that is not a shift and the only one that can put detail back into a blown sky rather than merely darken it. The four checks pin the develop down where it can only run in a browser: raw-develop-check, preview-match-check, white-level-check, highlight-knee-check.
87 lines
4.8 KiB
JavaScript
87 lines
4.8 KiB
JavaScript
// Highlight roll-off, both ends of the pipeline, as one soft knee:
|
|
//
|
|
// L' = L , L < T
|
|
// L' = T + (L - T) / (1 + 2 S (L - T)) , L >= T
|
|
//
|
|
// The develop draws it on the sensor's own levels (T = 0.7, S = 1 / (2 (1 - T)),
|
|
// which puts the asymptote on 1.0) so the two stops the sensor holds above its
|
|
// white level are COMPRESSED into the frame instead of being thrown away by the
|
|
// old fade-to-white; the tone pass draws the same curve in linear light on the
|
|
// value the develop and the camera match left, where -HL is the knob (T = 0.5,
|
|
// S = |hl|). Before this, a blown sky left the develop on exactly 1.0 in all
|
|
// three channels and HL had a flat white to pull on: measured on DSC03453.ARW,
|
|
// where the camera's own preview is clipped the develop's luma was 253.4 with a
|
|
// standard deviation of 2.4, against 251.2 / 10.0 through the knee.
|
|
//
|
|
// Both are SkSL, so the shape is pinned on the source; the curve itself is
|
|
// checked as arithmetic, with the constants the source is asserted to carry.
|
|
//
|
|
// node scripts/highlight-knee-check.mjs
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
|
|
const develop = readFileSync(new URL('../src/engine/rawDevelop.ts', import.meta.url), 'utf8');
|
|
const tone = readFileSync(new URL('../shared/utils/toneShader.ts', import.meta.url), 'utf8');
|
|
|
|
// The develop: knee on the sensor's max channel, the channel ratios kept, so the
|
|
// hue and the saturation of a blown area survive the pull-down.
|
|
const dev = develop.match(/if \(mx > 0\.7\) \{[\s\S]*?\n \}/)?.[0];
|
|
assert.ok(dev, 'the develop knee is gone — a blown sky is flat 1.0 again');
|
|
assert.match(dev, /float over = mx - 0\.7;/);
|
|
assert.match(dev, /rgb \*= \(0\.7 \+ over \/ \(1\.0 \+ over \* 3\.3333\)\) \/ mx;/);
|
|
assert.doesNotMatch(develop, /mix\(rgb \/ mx, float3\(1\.0\)/, 'the fade-to-white is back');
|
|
|
|
// The tone pass: the knee runs in LINEAR light and before the luma is read, the
|
|
// lift keeps its headroom weight — and the recovery must not also ride the
|
|
// additive term, which would darken the white the knee protects.
|
|
assert.match(tone, /if \(hl < 0\.0\) \{/);
|
|
assert.match(tone, /vec3 lin = toLinear\(rgb\);/);
|
|
assert.match(tone, /float l0 = dot\(lin, vec3\(0\.2126, 0\.7152, 0\.0722\)\);/);
|
|
assert.match(tone, /lin \*= \(0\.5 \+ over \/ \(1\.0 \+ S \* over \* 2\.0\)\) \/ l0;/);
|
|
assert.match(tone, /rgb = clamp\(toEncoded\(lin\), 0\.0, 1\.0\);/);
|
|
assert.match(tone, /float o = t \+ max\(hl, 0\.0\) \* hlMask \* \(1\.0 - t\) \+ sh \* 0\.34 \* shMask;/);
|
|
// The transfer pair has to be the accurate one, or the knee is drawn in a space
|
|
// that is not linear at all.
|
|
assert.match(tone, /return mix\(c \/ 12\.92, pow\(\(c \+ 0\.055\) \/ 1\.055, vec3\(2\.4\)\), step\(vec3\(0\.04045\), c\)\);/);
|
|
|
|
// The arithmetic. T = 0.7 / S = 1 / (2 (1 - T)) is the develop's pair (S is what
|
|
// puts the asymptote on 1.0: T + 1/(2S) = 1); T = 0.5 with S = 1 is the top of
|
|
// the tone pass's knob.
|
|
const knee = (l, T, S) => (l < T ? l : T + (l - T) / (1 + 2 * S * (l - T)));
|
|
|
|
for (const [T, S] of [
|
|
[0.7, 1 / (2 * (1 - 0.7))],
|
|
[0.5, 0.25],
|
|
[0.5, 1],
|
|
]) {
|
|
// Below the knee the frame is untouched, and the curve is continuous and C1 at
|
|
// T — slope 1 on both sides — so there is no seam for a later pass to mask.
|
|
assert.equal(knee(T - 0.2, T, S), T - 0.2);
|
|
assert.equal(knee(T, T, S), T);
|
|
const slope = (x) => (knee(x + 1e-6, T, S) - knee(x, T, S)) / 1e-6;
|
|
assert.ok(Math.abs(slope(T) - 1) < 1e-3, `seam at T=${T}: slope ${slope(T)}`);
|
|
// Monotone, and never a brightening: a recovery slider that lifted a highlight
|
|
// would be a lift in disguise, and an inverted pair of pixels is a visible edge.
|
|
let prev = -Infinity;
|
|
for (let l = 0; l <= 2; l += 1 / 512) {
|
|
assert.ok(slope(l) > 0, `inverted at ${l} (T=${T}, S=${S})`);
|
|
assert.ok(knee(l, T, S) <= l + 1e-9, `brightened ${l} -> ${knee(l, T, S)}`);
|
|
assert.ok(knee(l, T, S) >= prev);
|
|
prev = knee(l, T, S);
|
|
}
|
|
// The asymptote: everything the sensor held above the knee lands under it.
|
|
// The develop's pair puts it exactly on 1.0, the tone pass's S = 1 on 0.75.
|
|
assert.ok(Math.abs(knee(1e6, T, S) - (T + 1 / (2 * S))) < 1e-4);
|
|
}
|
|
assert.ok(Math.abs(0.7 + 1 / (2 * (1 / (2 * (1 - 0.7)))) - 1) < 1e-9, 'the develop plateau left 1.0');
|
|
// ...and the same pair in the encoded domain, which is the domain the develop
|
|
// hands over: mx = 1.0 (the white level) lands on 237, the sensor's own plateau
|
|
// (1.93, see the gain above) on 248 — a ramp of a dozen code values where the
|
|
// old fade-to-white left nothing above 250 at all.
|
|
const enc = (x) => (x <= 0.0031308 ? x * 12.92 : 1.055 * x ** (1 / 2.4) - 0.055);
|
|
const DEV_S = 1 / (2 * (1 - 0.7));
|
|
assert.equal(Math.round(enc(knee(1.0, 0.7, DEV_S)) * 255), 237);
|
|
assert.equal(Math.round(enc(knee(1.93, 0.7, DEV_S)) * 255), 248);
|
|
|
|
console.log('highlight-knee-check ok');
|