LCOV - code coverage report
Current view: top level - src/renderer/hdr - hdrStats.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 89.6 % 48 43
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : export interface ImageStats {
       2              :   min: number
       3              :   max: number
       4              :   mean: number
       5              :   stdDev: number
       6              :   nanCount: number
       7              :   infCount: number
       8              : }
       9              : 
      10            2 : export function computeImageStats(
      11              :   read: (index: number) => number,
      12              :   length: number,
      13              :   channels: number
      14              : ): ImageStats {
      15            2 :   let min = Infinity
      16            2 :   let max = -Infinity
      17            2 :   let sum = 0
      18            2 :   let sumSq = 0
      19            2 :   let count = 0
      20            2 :   let nanCount = 0
      21            2 :   let infCount = 0
      22              : 
      23            2 :   for (let i = 0; i < length; i++) {
      24           32 :     const value = read(i)
      25           32 :     if (Number.isNaN(value)) {
      26            0 :       nanCount++
      27            0 :       continue
      28              :     }
      29           32 :     if (!Number.isFinite(value)) {
      30            0 :       infCount++
      31            0 :       continue
      32              :     }
      33           32 :     if (channels === 4 && i % channels === 3) continue
      34           32 :     if (value < min) min = value
      35           32 :     if (value > max) max = value
      36           24 :     sum += value
      37           24 :     sumSq += value * value
      38           24 :     count++
      39              :   }
      40              : 
      41            2 :   if (count === 0) {
      42            0 :     return { min: 0, max: 0, mean: 0, stdDev: 0, nanCount, infCount }
      43              :   }
      44              : 
      45            2 :   const mean = sum / count
      46            2 :   const variance = Math.max(0, sumSq / count - mean * mean)
      47            2 :   return { min, max, mean, stdDev: Math.sqrt(variance), nanCount, infCount }
      48              : }
      49              : 
      50              : export interface ChannelHistograms {
      51              :   r: Uint32Array
      52              :   g: Uint32Array
      53              :   b: Uint32Array
      54              :   a: Uint32Array | null
      55              :   luminance: Uint32Array
      56              : }
      57              : 
      58            2 : export function computeChannelHistograms(
      59              :   read: (index: number) => number,
      60              :   length: number,
      61              :   channels: number,
      62              :   bins = 256
      63              : ): ChannelHistograms {
      64            2 :   const last = bins - 1
      65            2 :   const r = new Uint32Array(bins)
      66            2 :   const g = new Uint32Array(bins)
      67            2 :   const b = new Uint32Array(bins)
      68            2 :   const luminance = new Uint32Array(bins)
      69            2 :   const a = channels === 4 ? new Uint32Array(bins) : null
      70              : 
      71            2 :   const accumulate = (target: Uint32Array, value: number) => {
      72           40 :     if (Number.isNaN(value)) return
      73           40 :     const bin = Math.floor(Math.max(0, value) * bins)
      74           40 :     target[bin > last ? last : bin]++
      75              :   }
      76              : 
      77            2 :   for (let i = 0; i + channels - 1 < length; i += channels) {
      78            8 :     const rv = read(i)
      79            8 :     const gv = channels >= 3 ? read(i + 1) : rv
      80            8 :     const bv = channels >= 3 ? read(i + 2) : rv
      81            8 :     accumulate(r, rv)
      82            8 :     accumulate(g, gv)
      83            8 :     accumulate(b, bv)
      84            8 :     if (a) accumulate(a, read(i + 3))
      85            8 :     accumulate(
      86              :       luminance,
      87              :       channels >= 3 ? 0.2126 * rv + 0.7152 * gv + 0.0722 * bv : rv
      88              :     )
      89              :   }
      90              : 
      91            2 :   return { r, g, b, a, luminance }
      92              : }
        

Generated by: LCOV version 2.0-1