LCOV - code coverage report
Current view: top level - src/composables - useHdrViewer.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 68.1 % 226 154
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { Point2D } from '@comfyorg/shared-frontend-utils/geometry'
       2              : import * as THREE from 'three'
       3              : import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader'
       4              : import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader'
       5              : import { computed, onUnmounted, ref, shallowRef, watch } from 'vue'
       6              : 
       7              : import type { ChromaticityCoords, GamutName } from '@/renderer/hdr/colorGamut'
       8              : import {
       9              :   detectGamutFromChromaticities,
      10              :   gamutToSrgbMatrix
      11              : } from '@/renderer/hdr/colorGamut'
      12              : import {
      13              :   HDR_VIEWER_FRAGMENT_SHADER,
      14              :   HDR_VIEWER_VERTEX_SHADER
      15              : } from '@/renderer/hdr/hdrViewerShader'
      16              : import type { ChannelHistograms, ImageStats } from '@/renderer/hdr/hdrStats'
      17              : import {
      18              :   computeChannelHistograms,
      19              :   computeImageStats
      20              : } from '@/renderer/hdr/hdrStats'
      21              : import { WebGLViewport } from '@comfyorg/viewport3d/three/WebGLViewport'
      22              : import { getImageFilenameFromUrl } from '@/utils/hdrFormatUtil'
      23              : 
      24            2 : const MIN_ZOOM = 0.05
      25            2 : const MAX_ZOOM = 64
      26            2 : const CHECKER_CSS_PX = 8
      27              : 
      28              : export type ChannelMode = 'rgb' | 'r' | 'g' | 'b' | 'a' | 'luminance'
      29              : 
      30            2 : export const CHANNEL_MODES: ChannelMode[] = [
      31              :   'rgb',
      32              :   'r',
      33              :   'g',
      34              :   'b',
      35              :   'a',
      36              :   'luminance'
      37              : ]
      38              : 
      39            2 : const CHANNEL_INDEX: Record<ChannelMode, number> = {
      40              :   rgb: 0,
      41              :   r: 1,
      42              :   g: 2,
      43              :   b: 3,
      44              :   a: 4,
      45              :   luminance: 5
      46              : }
      47              : 
      48              : interface PixelReadout extends Point2D {
      49              :   r: number
      50              :   g: number
      51              :   b: number
      52              :   a: number | null
      53              : }
      54              : 
      55              : interface ExrTexData {
      56              :   header?: { chromaticities?: ChromaticityCoords }
      57              : }
      58              : 
      59            2 : function createLoader(url: string) {
      60              :   const filename = getImageFilenameFromUrl(url)
      61            2 :   if (filename?.toLowerCase().endsWith('.hdr')) return new RGBELoader()
      62            2 :   const loader = new EXRLoader()
      63            2 :   loader.setDataType(THREE.FloatType)
      64            2 :   return loader
      65              : }
      66              : 
      67            2 : function makeReader(
      68              :   data: ArrayLike<number>,
      69              :   type: THREE.TextureDataType
      70              : ): (index: number) => number {
      71            2 :   if (type === THREE.HalfFloatType) {
      72            0 :     return (index) => THREE.DataUtils.fromHalfFloat(data[index])
      73              :   }
      74            2 :   return (index) => data[index]
      75              : }
      76              : 
      77            2 : function loadHdrTexture(
      78              :   url: string
      79              : ): Promise<{ texture: THREE.DataTexture; gamut: GamutName }> {
      80            2 :   return new Promise((resolve, reject) => {
      81            2 :     createLoader(url).load(
      82              :       url,
      83              :       (texture, texData) => {
      84            2 :         const chromaticities = (texData as ExrTexData).header?.chromaticities
      85            2 :         resolve({
      86              :           texture,
      87              :           gamut: detectGamutFromChromaticities(chromaticities)
      88              :         })
      89              :       },
      90              :       undefined,
      91              :       reject
      92              :     )
      93              :   })
      94              : }
      95              : 
      96            2 : export function useHdrViewer() {
      97            2 :   const exposureStops = ref(0)
      98            2 :   const dither = ref(true)
      99            2 :   const clipWarnings = ref(false)
     100            2 :   const checkerboard = ref(true)
     101            2 :   const gamut = ref<GamutName>('sRGB')
     102            2 :   const channel = ref<ChannelMode>('rgb')
     103            2 :   const loading = ref(true)
     104            2 :   const error = ref<string | null>(null)
     105            2 :   const dimensions = ref<string | null>(null)
     106            2 :   const stats = ref<ImageStats | null>(null)
     107            2 :   const histograms = shallowRef<ChannelHistograms | null>(null)
     108            2 :   const pixel = ref<PixelReadout | null>(null)
     109              : 
     110            2 :   const histogram = computed<Uint32Array | null>(() => {
     111            4 :     const channelHistograms = histograms.value
     112            4 :     if (!channelHistograms) return null
     113            4 :     switch (channel.value) {
     114              :       case 'r':
     115            0 :         return channelHistograms.r
     116              :       case 'g':
     117            0 :         return channelHistograms.g
     118              :       case 'b':
     119            0 :         return channelHistograms.b
     120              :       case 'a':
     121            0 :         return channelHistograms.a
     122              :       default:
     123            2 :         return channelHistograms.luminance
     124              :     }
     125              :   })
     126              : 
     127            2 :   const containerRef = shallowRef<HTMLElement | null>(null)
     128              : 
     129            2 :   let renderer: THREE.WebGLRenderer | null = null
     130            2 :   let viewport: WebGLViewport | null = null
     131            2 :   let scene: THREE.Scene | null = null
     132            2 :   let camera: THREE.OrthographicCamera | null = null
     133            2 :   let material: THREE.ShaderMaterial | null = null
     134            2 :   let mesh: THREE.Mesh | null = null
     135            2 :   let texture: THREE.Texture | null = null
     136            2 :   let imageAspect = 1
     137            2 :   let frameRequested = false
     138              : 
     139            2 :   let readSample: ((index: number) => number) | null = null
     140            2 :   let imageWidth = 0
     141            2 :   let imageHeight = 0
     142            2 :   let imageChannels = 4
     143              : 
     144            2 :   const raycaster = new THREE.Raycaster()
     145            2 :   const pointerNdc = new THREE.Vector2()
     146              : 
     147           10 :   function requestRender() {
     148           10 :     if (!renderer || frameRequested) return
     149            5 :     frameRequested = true
     150            5 :     requestAnimationFrame(() => {
     151            5 :       frameRequested = false
     152            5 :       if (renderer && scene && camera) renderer.render(scene, camera)
     153              :     })
     154              :   }
     155              : 
     156           10 :   function containerSize() {
     157           10 :     const el = containerRef.value
     158           10 :     return {
     159              :       width: el?.clientWidth || 1,
     160              :       height: el?.clientHeight || 1
     161              :     }
     162              :   }
     163              : 
     164            4 :   function updateProjection() {
     165            4 :     if (!camera) return
     166            4 :     const { width, height } = containerSize()
     167            4 :     const halfH = 0.5
     168            4 :     const halfW = (0.5 * width) / height
     169            4 :     camera.left = -halfW
     170            4 :     camera.right = halfW
     171            4 :     camera.top = halfH
     172            4 :     camera.bottom = -halfH
     173            4 :     camera.updateProjectionMatrix()
     174              :   }
     175              : 
     176            2 :   function fitView() {
     177            2 :     if (!camera) return
     178            2 :     const { width, height } = containerSize()
     179            2 :     const containerAspect = width / height
     180            2 :     camera.zoom = Math.min(1, containerAspect / imageAspect)
     181            2 :     camera.position.set(0, 0, 1)
     182            2 :     camera.updateProjectionMatrix()
     183            2 :     requestRender()
     184              :   }
     185              : 
     186            4 :   function applyUniforms() {
     187            4 :     if (!material) return
     188            4 :     material.uniforms.uGain.value = Math.pow(2, exposureStops.value)
     189            4 :     material.uniforms.uDither.value = dither.value
     190            4 :     material.uniforms.uClipWarnings.value = clipWarnings.value
     191            4 :     material.uniforms.uCheckerboard.value = checkerboard.value
     192            4 :     material.uniforms.uChannel.value = CHANNEL_INDEX[channel.value]
     193            4 :     const m = gamutToSrgbMatrix(gamut.value)
     194            4 :     ;(material.uniforms.uGamutToSRGB.value as THREE.Matrix3).set(
     195              :       m[0],
     196              :       m[1],
     197              :       m[2],
     198              :       m[3],
     199              :       m[4],
     200              :       m[5],
     201              :       m[6],
     202              :       m[7],
     203              :       m[8]
     204              :     )
     205            4 :     requestRender()
     206              :   }
     207              : 
     208            2 :   function buildScene() {
     209            2 :     renderer = new THREE.WebGLRenderer({ antialias: false, alpha: false })
     210            2 :     viewport = new WebGLViewport(renderer)
     211            2 :     renderer.outputColorSpace = THREE.LinearSRGBColorSpace
     212            2 :     renderer.setPixelRatio(window.devicePixelRatio)
     213            2 :     renderer.setClearColor(0x0a0a0a, 1)
     214              : 
     215            2 :     scene = new THREE.Scene()
     216            2 :     camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.1, 10)
     217            2 :     camera.position.set(0, 0, 1)
     218              : 
     219            2 :     material = new THREE.ShaderMaterial({
     220              :       glslVersion: THREE.GLSL3,
     221              :       vertexShader: HDR_VIEWER_VERTEX_SHADER,
     222              :       fragmentShader: HDR_VIEWER_FRAGMENT_SHADER,
     223              :       uniforms: {
     224              :         uImage: { value: null },
     225              :         uGamutToSRGB: { value: new THREE.Matrix3() },
     226              :         uGain: { value: 1 },
     227              :         uChannel: { value: 0 },
     228              :         uDither: { value: true },
     229              :         uClipWarnings: { value: false },
     230              :         uClipRange: { value: new THREE.Vector2(0, 1) },
     231              :         uCheckerboard: { value: true },
     232              :         uCheckerSize: { value: CHECKER_CSS_PX * renderer.getPixelRatio() }
     233              :       }
     234              :     })
     235              : 
     236            2 :     mesh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), material)
     237            2 :     scene.add(mesh)
     238              :   }
     239              : 
     240            4 :   function resize() {
     241            4 :     if (!renderer) return
     242            4 :     const { width, height } = containerSize()
     243            4 :     renderer.setSize(width, height, false)
     244            4 :     updateProjection()
     245            4 :     requestRender()
     246              :   }
     247              : 
     248            2 :   function setTexture(loaded: THREE.DataTexture) {
     249            2 :     if (!material || !mesh) return
     250            2 :     loaded.colorSpace = THREE.LinearSRGBColorSpace
     251            2 :     loaded.minFilter = THREE.LinearFilter
     252            2 :     loaded.magFilter = THREE.LinearFilter
     253            2 :     loaded.needsUpdate = true
     254              : 
     255            2 :     const { width, height, data } = loaded.image
     256            2 :     texture = loaded
     257            2 :     imageAspect = width / height
     258            2 :     mesh.scale.set(imageAspect, 1, 1)
     259            2 :     material.uniforms.uImage.value = loaded
     260            2 :     dimensions.value = `${width} x ${height}`
     261              : 
     262            2 :     if (!data) return
     263            2 :     imageWidth = width
     264            2 :     imageHeight = height
     265            2 :     imageChannels = data.length / (width * height)
     266            2 :     readSample = makeReader(data, loaded.type)
     267            2 :     stats.value = computeImageStats(readSample, data.length, imageChannels)
     268            2 :     histograms.value = computeChannelHistograms(
     269              :       readSample,
     270              :       data.length,
     271              :       imageChannels
     272              :     )
     273              :   }
     274              : 
     275            2 :   async function mount(container: HTMLElement, url: string) {
     276            2 :     containerRef.value = container
     277            2 :     loading.value = true
     278            2 :     error.value = null
     279              : 
     280            2 :     try {
     281            2 :       buildScene()
     282            2 :       container.appendChild(renderer!.domElement)
     283            2 :       renderer!.domElement.classList.add('block', 'size-full')
     284            2 :       resize()
     285            2 :       applyUniforms()
     286            2 :       attachInteractions(renderer!.domElement)
     287            2 :       viewport!.observeResize(container, resize)
     288              : 
     289            2 :       const { texture: loaded, gamut: detectedGamut } =
     290              :         await loadHdrTexture(url)
     291            2 :       if (!material || !mesh) {
     292            0 :         loaded.dispose()
     293            0 :         return
     294              :       }
     295            2 :       gamut.value = detectedGamut
     296            2 :       setTexture(loaded)
     297            2 :       applyUniforms()
     298            2 :       fitView()
     299              :     } catch (e) {
     300            0 :       error.value = e instanceof Error ? e.message : String(e)
     301            0 :       dispose()
     302              :     } finally {
     303            2 :       loading.value = false
     304              :     }
     305              :   }
     306              : 
     307            0 :   function normalizeExposure() {
     308            0 :     const max = stats.value?.max ?? 0
     309            0 :     exposureStops.value = max > 0 ? -Math.log2(max) : 0
     310              :   }
     311              : 
     312            2 :   function attachInteractions(canvas: HTMLCanvasElement) {
     313            2 :     canvas.addEventListener('wheel', onWheel, { passive: false })
     314            2 :     canvas.addEventListener('pointerdown', onPointerDown)
     315            2 :     canvas.addEventListener('pointermove', onHoverMove)
     316            2 :     canvas.addEventListener('pointerleave', onHoverLeave)
     317              :   }
     318              : 
     319            0 :   function onWheel(event: WheelEvent) {
     320            0 :     if (!camera) return
     321            0 :     event.preventDefault()
     322            0 :     const factor = Math.exp(-event.deltaY * 0.001)
     323            0 :     const nextZoom = THREE.MathUtils.clamp(
     324              :       camera.zoom * factor,
     325              :       MIN_ZOOM,
     326              :       MAX_ZOOM
     327              :     )
     328            0 :     camera.zoom = nextZoom
     329            0 :     camera.updateProjectionMatrix()
     330            0 :     requestRender()
     331              :   }
     332              : 
     333            2 :   let dragStart: (Point2D & { camX: number; camY: number }) | null = null
     334              : 
     335            0 :   function onPointerDown(event: PointerEvent) {
     336            0 :     if (!camera) return
     337            0 :     dragStart = {
     338              :       x: event.clientX,
     339              :       y: event.clientY,
     340              :       camX: camera.position.x,
     341              :       camY: camera.position.y
     342              :     }
     343            0 :     window.addEventListener('pointermove', onPointerMove)
     344            0 :     window.addEventListener('pointerup', onPointerUp)
     345              :   }
     346              : 
     347            0 :   function onPointerMove(event: PointerEvent) {
     348            0 :     if (!camera || !dragStart) return
     349            0 :     const { height } = containerSize()
     350            0 :     const worldPerPixel = 1 / (height * camera.zoom)
     351            0 :     camera.position.x =
     352              :       dragStart.camX - (event.clientX - dragStart.x) * worldPerPixel
     353            0 :     camera.position.y =
     354              :       dragStart.camY + (event.clientY - dragStart.y) * worldPerPixel
     355            0 :     requestRender()
     356              :   }
     357              : 
     358            0 :   function onPointerUp() {
     359            0 :     dragStart = null
     360            0 :     window.removeEventListener('pointermove', onPointerMove)
     361            0 :     window.removeEventListener('pointerup', onPointerUp)
     362              :   }
     363              : 
     364            0 :   function onHoverMove(event: PointerEvent) {
     365            0 :     if (!camera || !mesh || !renderer || dragStart || !readSample) return
     366            0 :     const rect = renderer.domElement.getBoundingClientRect()
     367            0 :     pointerNdc.x = ((event.clientX - rect.left) / rect.width) * 2 - 1
     368            0 :     pointerNdc.y = -(((event.clientY - rect.top) / rect.height) * 2 - 1)
     369            0 :     raycaster.setFromCamera(pointerNdc, camera)
     370            0 :     const hit = raycaster.intersectObject(mesh).at(0)
     371            0 :     if (!hit?.uv) {
     372            0 :       pixel.value = null
     373            0 :       return
     374              :     }
     375            0 :     const col = THREE.MathUtils.clamp(
     376              :       Math.floor(hit.uv.x * imageWidth),
     377              :       0,
     378              :       imageWidth - 1
     379              :     )
     380            0 :     const row = THREE.MathUtils.clamp(
     381              :       Math.floor(hit.uv.y * imageHeight),
     382              :       0,
     383              :       imageHeight - 1
     384              :     )
     385            0 :     const base = (row * imageWidth + col) * imageChannels
     386            0 :     pixel.value = {
     387              :       x: col,
     388              :       y: imageHeight - 1 - row,
     389              :       r: readSample(base),
     390              :       g: readSample(base + 1),
     391              :       b: readSample(base + 2),
     392              :       a: imageChannels === 4 ? readSample(base + 3) : null
     393              :     }
     394              :   }
     395              : 
     396            0 :   function onHoverLeave() {
     397            0 :     pixel.value = null
     398              :   }
     399              : 
     400            0 :   function dispose() {
     401            0 :     window.removeEventListener('pointermove', onPointerMove)
     402            0 :     window.removeEventListener('pointerup', onPointerUp)
     403              : 
     404            0 :     if (renderer) {
     405            0 :       renderer.domElement.removeEventListener('wheel', onWheel)
     406            0 :       renderer.domElement.removeEventListener('pointerdown', onPointerDown)
     407            0 :       renderer.domElement.removeEventListener('pointermove', onHoverMove)
     408            0 :       renderer.domElement.removeEventListener('pointerleave', onHoverLeave)
     409              :     }
     410            0 :     viewport?.disposeRenderer()
     411            0 :     texture?.dispose()
     412            0 :     material?.dispose()
     413            0 :     mesh?.geometry.dispose()
     414              : 
     415            0 :     renderer = null
     416            0 :     viewport = null
     417            0 :     scene = null
     418            0 :     camera = null
     419            0 :     material = null
     420            0 :     mesh = null
     421            0 :     texture = null
     422            0 :     readSample = null
     423              :   }
     424              : 
     425            2 :   watch(
     426              :     [exposureStops, dither, clipWarnings, checkerboard, gamut, channel],
     427              :     applyUniforms
     428              :   )
     429              : 
     430            2 :   onUnmounted(dispose)
     431              : 
     432            2 :   return {
     433              :     exposureStops,
     434              :     dither,
     435              :     clipWarnings,
     436              :     checkerboard,
     437              :     gamut,
     438              :     channel,
     439              :     loading,
     440              :     error,
     441              :     dimensions,
     442              :     stats,
     443              :     histogram,
     444              :     pixel,
     445              :     mount,
     446              :     dispose,
     447              :     fitView,
     448              :     normalizeExposure
     449              :   }
     450              : }
        

Generated by: LCOV version 2.0-1