LCOV - code coverage report
Current view: top level - src/renderer/hdr - colorGamut.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 70.5 % 44 31
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : interface Chromaticities {
       2              :   red: readonly [number, number]
       3              :   green: readonly [number, number]
       4              :   blue: readonly [number, number]
       5              :   white: readonly [number, number]
       6              : }
       7              : 
       8            2 : const D65: readonly [number, number] = [0.3127, 0.329]
       9              : 
      10            2 : const CHROMATICITIES = {
      11              :   sRGB: {
      12              :     red: [0.64, 0.33],
      13              :     green: [0.3, 0.6],
      14              :     blue: [0.15, 0.06],
      15              :     white: D65
      16              :   },
      17              :   'Rec.2020': {
      18              :     red: [0.708, 0.292],
      19              :     green: [0.17, 0.797],
      20              :     blue: [0.131, 0.046],
      21              :     white: D65
      22              :   }
      23              : } satisfies Record<string, Chromaticities>
      24              : 
      25              : export type GamutName = keyof typeof CHROMATICITIES
      26              : 
      27            2 : export const GAMUT_NAMES = Object.keys(CHROMATICITIES) as GamutName[]
      28              : 
      29              : type Mat3 = readonly number[]
      30              : 
      31            2 : const IDENTITY: Mat3 = [1, 0, 0, 0, 1, 0, 0, 0, 1]
      32              : 
      33            2 : function rgbToXyz(c: Chromaticities): Mat3 {
      34            2 :   const [rx, ry] = c.red
      35            2 :   const [gx, gy] = c.green
      36            2 :   const [bx, by] = c.blue
      37            2 :   const [wx, wy] = c.white
      38              : 
      39            2 :   const xWhite = wx / wy
      40            2 :   const zWhite = (1 - wx - wy) / wy
      41              : 
      42            2 :   const d = rx * (by - gy) + bx * (gy - ry) + gx * (ry - by)
      43              : 
      44            2 :   const srN =
      45              :     xWhite * (by - gy) -
      46              :     gx * (by - 1 + by * (xWhite + zWhite)) +
      47              :     bx * (gy - 1 + gy * (xWhite + zWhite))
      48            2 :   const sgN =
      49              :     xWhite * (ry - by) +
      50              :     rx * (by - 1 + by * (xWhite + zWhite)) -
      51              :     bx * (ry - 1 + ry * (xWhite + zWhite))
      52            2 :   const sbN =
      53              :     xWhite * (gy - ry) -
      54              :     rx * (gy - 1 + gy * (xWhite + zWhite)) +
      55              :     gx * (ry - 1 + ry * (xWhite + zWhite))
      56              : 
      57            2 :   const sr = srN / d
      58            2 :   const sg = sgN / d
      59            2 :   const sb = sbN / d
      60              : 
      61            2 :   return [
      62              :     sr * rx,
      63              :     sg * gx,
      64              :     sb * bx,
      65              :     sr * ry,
      66              :     sg * gy,
      67              :     sb * by,
      68              :     sr * (1 - rx - ry),
      69              :     sg * (1 - gx - gy),
      70              :     sb * (1 - bx - by)
      71              :   ]
      72              : }
      73              : 
      74            0 : function multiply(a: Mat3, b: Mat3): Mat3 {
      75            0 :   const result = Array.from({ length: 9 }, () => 0)
      76            0 :   for (let row = 0; row < 3; row++) {
      77            0 :     for (let col = 0; col < 3; col++) {
      78            0 :       let sum = 0
      79            0 :       for (let k = 0; k < 3; k++) sum += a[row * 3 + k] * b[k * 3 + col]
      80            0 :       result[row * 3 + col] = sum
      81              :     }
      82              :   }
      83            0 :   return result
      84              : }
      85              : 
      86            2 : function invert(m: Mat3): Mat3 {
      87            2 :   const [a, b, c, d, e, f, g, h, i] = m
      88            2 :   const det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g)
      89            2 :   if (det === 0) return IDENTITY
      90              : 
      91            2 :   const invDet = 1 / det
      92            2 :   return [
      93              :     (e * i - f * h) * invDet,
      94              :     (c * h - b * i) * invDet,
      95              :     (b * f - c * e) * invDet,
      96              :     (f * g - d * i) * invDet,
      97              :     (a * i - c * g) * invDet,
      98              :     (c * d - a * f) * invDet,
      99              :     (d * h - e * g) * invDet,
     100              :     (b * g - a * h) * invDet,
     101              :     (a * e - b * d) * invDet
     102              :   ]
     103              : }
     104              : 
     105              : const SRGB_TO_XYZ = rgbToXyz(CHROMATICITIES.sRGB)
     106            2 : const XYZ_TO_SRGB = invert(SRGB_TO_XYZ)
     107              : 
     108            4 : export function gamutToSrgbMatrix(gamut: GamutName): Mat3 {
     109            4 :   if (gamut === 'sRGB') return IDENTITY
     110            0 :   return multiply(XYZ_TO_SRGB, rgbToXyz(CHROMATICITIES[gamut]))
     111              : }
     112              : 
     113              : export interface ChromaticityCoords {
     114              :   redX: number
     115              :   redY: number
     116              :   greenX: number
     117              :   greenY: number
     118              :   blueX: number
     119              :   blueY: number
     120              :   whiteX: number
     121              :   whiteY: number
     122              : }
     123              : 
     124            0 : function matchesGamut(c: ChromaticityCoords, gamut: GamutName): boolean {
     125            0 :   const ref = CHROMATICITIES[gamut]
     126            0 :   const tol = 0.01
     127            0 :   return (
     128              :     Math.abs(c.redX - ref.red[0]) < tol &&
     129              :     Math.abs(c.redY - ref.red[1]) < tol &&
     130              :     Math.abs(c.greenX - ref.green[0]) < tol &&
     131              :     Math.abs(c.greenY - ref.green[1]) < tol &&
     132              :     Math.abs(c.blueX - ref.blue[0]) < tol &&
     133              :     Math.abs(c.blueY - ref.blue[1]) < tol &&
     134              :     Math.abs(c.whiteX - ref.white[0]) < tol &&
     135              :     Math.abs(c.whiteY - ref.white[1]) < tol
     136              :   )
     137              : }
     138              : 
     139            2 : export function detectGamutFromChromaticities(
     140              :   c: ChromaticityCoords | undefined
     141              : ): GamutName {
     142            2 :   if (!c) return 'sRGB'
     143            2 :   return GAMUT_NAMES.find((name) => matchesGamut(c, name)) ?? 'sRGB'
     144              : }
        

Generated by: LCOV version 2.0-1