LCOV - code coverage report
Current view: top level - packages/mask-editor/src - useCanvasTransform.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 7.2 % 138 10
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { premultiplyData } from './brushDrawingUtils'
       2              : import { useMaskEditorStore } from './maskEditorStore'
       3              : 
       4           31 : export function useCanvasTransform() {
       5           31 :   const store = useMaskEditorStore()
       6              : 
       7           31 :   const rotateCanvas = (
       8              :     ctx: CanvasRenderingContext2D,
       9              :     canvas: HTMLCanvasElement,
      10              :     clockwise: boolean
      11              :   ): ImageData => {
      12            0 :     const width = canvas.width
      13            0 :     const height = canvas.height
      14              : 
      15            0 :     const sourceData = ctx.getImageData(0, 0, width, height)
      16              : 
      17            0 :     const rotatedData = new ImageData(height, width)
      18            0 :     const src = sourceData.data
      19            0 :     const dst = rotatedData.data
      20              : 
      21            0 :     for (let y = 0; y < height; y++) {
      22            0 :       for (let x = 0; x < width; x++) {
      23            0 :         const srcIdx = (y * width + x) * 4
      24              : 
      25            0 :         let dstX: number, dstY: number
      26            0 :         if (clockwise) {
      27            0 :           dstX = height - 1 - y
      28            0 :           dstY = x
      29              :         } else {
      30            0 :           dstX = y
      31            0 :           dstY = width - 1 - x
      32              :         }
      33              : 
      34            0 :         const dstIdx = (dstY * height + dstX) * 4
      35              : 
      36            0 :         dst[dstIdx] = src[srcIdx]
      37            0 :         dst[dstIdx + 1] = src[srcIdx + 1]
      38            0 :         dst[dstIdx + 2] = src[srcIdx + 2]
      39            0 :         dst[dstIdx + 3] = src[srcIdx + 3]
      40              :       }
      41              :     }
      42              : 
      43            0 :     return rotatedData
      44              :   }
      45              : 
      46           31 :   const mirrorCanvas = (
      47              :     ctx: CanvasRenderingContext2D,
      48              :     canvas: HTMLCanvasElement,
      49              :     horizontal: boolean
      50              :   ): ImageData => {
      51            0 :     const width = canvas.width
      52            0 :     const height = canvas.height
      53              : 
      54            0 :     const sourceData = ctx.getImageData(0, 0, width, height)
      55            0 :     const mirroredData = new ImageData(width, height)
      56            0 :     const src = sourceData.data
      57            0 :     const dst = mirroredData.data
      58              : 
      59            0 :     for (let y = 0; y < height; y++) {
      60            0 :       for (let x = 0; x < width; x++) {
      61            0 :         const srcIdx = (y * width + x) * 4
      62              : 
      63            0 :         let dstX: number, dstY: number
      64            0 :         if (horizontal) {
      65            0 :           dstX = width - 1 - x
      66            0 :           dstY = y
      67              :         } else {
      68            0 :           dstX = x
      69            0 :           dstY = height - 1 - y
      70              :         }
      71              : 
      72            0 :         const dstIdx = (dstY * width + dstX) * 4
      73              : 
      74            0 :         dst[dstIdx] = src[srcIdx]
      75            0 :         dst[dstIdx + 1] = src[srcIdx + 1]
      76            0 :         dst[dstIdx + 2] = src[srcIdx + 2]
      77            0 :         dst[dstIdx + 3] = src[srcIdx + 3]
      78              :       }
      79              :     }
      80              : 
      81            0 :     return mirroredData
      82              :   }
      83              : 
      84           31 :   const recreateGPUTextures = async (
      85              :     width: number,
      86              :     height: number
      87              :   ): Promise<void> => {
      88            0 :     if (
      89              :       !store.tgpuRoot ||
      90              :       !store.maskCanvas ||
      91              :       !store.rgbCanvas ||
      92              :       !store.maskCtx ||
      93              :       !store.rgbCtx
      94              :     ) {
      95            0 :       return
      96              :     }
      97              : 
      98            0 :     store.gpuTexturesNeedRecreation = true
      99            0 :     store.gpuTextureWidth = width
     100            0 :     store.gpuTextureHeight = height
     101              : 
     102            0 :     const maskImageData = store.maskCtx.getImageData(0, 0, width, height)
     103            0 :     const rgbImageData = store.rgbCtx.getImageData(0, 0, width, height)
     104              : 
     105            0 :     const maskData = new Uint8ClampedArray(
     106              :       new ArrayBuffer(maskImageData.data.length)
     107              :     )
     108            0 :     const rgbData = new Uint8ClampedArray(
     109              :       new ArrayBuffer(rgbImageData.data.length)
     110              :     )
     111              : 
     112            0 :     maskData.set(maskImageData.data)
     113            0 :     rgbData.set(rgbImageData.data)
     114              : 
     115            0 :     if (
     116              :       maskData.buffer instanceof SharedArrayBuffer ||
     117              :       rgbData.buffer instanceof SharedArrayBuffer
     118              :     ) {
     119            0 :       console.error(
     120              :         '[useCanvasTransform] SharedArrayBuffer detected, WebGPU writeTexture will fail'
     121              :       )
     122            0 :       return
     123              :     }
     124              : 
     125            0 :     premultiplyData(maskData)
     126            0 :     premultiplyData(rgbData)
     127              : 
     128            0 :     store.pendingGPUMaskData = maskData
     129            0 :     store.pendingGPURgbData = rgbData
     130              :   }
     131              : 
     132           31 :   const rotateClockwise = async (): Promise<void> => {
     133            0 :     const { maskCanvas, maskCtx, rgbCanvas, rgbCtx, imgCanvas, imgCtx } = store
     134              : 
     135            0 :     if (
     136              :       !maskCanvas ||
     137              :       !maskCtx ||
     138              :       !rgbCanvas ||
     139              :       !rgbCtx ||
     140              :       !imgCanvas ||
     141              :       !imgCtx
     142              :     ) {
     143            0 :       console.error('[useCanvasTransform] Canvas contexts not ready')
     144            0 :       return
     145              :     }
     146              : 
     147            0 :     const origWidth = maskCanvas.width
     148            0 :     const origHeight = maskCanvas.height
     149              : 
     150            0 :     const rotatedMask = rotateCanvas(maskCtx, maskCanvas, true)
     151            0 :     const rotatedRgb = rotateCanvas(rgbCtx, rgbCanvas, true)
     152            0 :     const rotatedImg = rotateCanvas(imgCtx, imgCanvas, true)
     153              : 
     154            0 :     maskCanvas.width = origHeight
     155            0 :     maskCanvas.height = origWidth
     156            0 :     rgbCanvas.width = origHeight
     157            0 :     rgbCanvas.height = origWidth
     158            0 :     imgCanvas.width = origHeight
     159            0 :     imgCanvas.height = origWidth
     160              : 
     161            0 :     maskCtx.putImageData(rotatedMask, 0, 0)
     162            0 :     rgbCtx.putImageData(rotatedRgb, 0, 0)
     163            0 :     imgCtx.putImageData(rotatedImg, 0, 0)
     164              : 
     165            0 :     if (store.tgpuRoot) {
     166            0 :       await recreateGPUTextures(origHeight, origWidth)
     167              :     }
     168              : 
     169            0 :     store.canvasHistory.saveState(rotatedMask, rotatedRgb, rotatedImg)
     170              :   }
     171              : 
     172           31 :   const rotateCounterclockwise = async (): Promise<void> => {
     173            0 :     const { maskCanvas, maskCtx, rgbCanvas, rgbCtx, imgCanvas, imgCtx } = store
     174              : 
     175            0 :     if (
     176              :       !maskCanvas ||
     177              :       !maskCtx ||
     178              :       !rgbCanvas ||
     179              :       !rgbCtx ||
     180              :       !imgCanvas ||
     181              :       !imgCtx
     182              :     ) {
     183            0 :       console.error('[useCanvasTransform] Canvas contexts not ready')
     184            0 :       return
     185              :     }
     186              : 
     187            0 :     const origWidth = maskCanvas.width
     188            0 :     const origHeight = maskCanvas.height
     189              : 
     190            0 :     const rotatedMask = rotateCanvas(maskCtx, maskCanvas, false)
     191            0 :     const rotatedRgb = rotateCanvas(rgbCtx, rgbCanvas, false)
     192            0 :     const rotatedImg = rotateCanvas(imgCtx, imgCanvas, false)
     193              : 
     194            0 :     maskCanvas.width = origHeight
     195            0 :     maskCanvas.height = origWidth
     196            0 :     rgbCanvas.width = origHeight
     197            0 :     rgbCanvas.height = origWidth
     198            0 :     imgCanvas.width = origHeight
     199            0 :     imgCanvas.height = origWidth
     200              : 
     201            0 :     maskCtx.putImageData(rotatedMask, 0, 0)
     202            0 :     rgbCtx.putImageData(rotatedRgb, 0, 0)
     203            0 :     imgCtx.putImageData(rotatedImg, 0, 0)
     204              : 
     205            0 :     if (store.tgpuRoot) {
     206            0 :       await recreateGPUTextures(origHeight, origWidth)
     207              :     }
     208              : 
     209            0 :     store.canvasHistory.saveState(rotatedMask, rotatedRgb, rotatedImg)
     210              :   }
     211              : 
     212           31 :   const mirrorHorizontal = async (): Promise<void> => {
     213            0 :     const { maskCanvas, maskCtx, rgbCanvas, rgbCtx, imgCanvas, imgCtx } = store
     214              : 
     215            0 :     if (
     216              :       !maskCanvas ||
     217              :       !maskCtx ||
     218              :       !rgbCanvas ||
     219              :       !rgbCtx ||
     220              :       !imgCanvas ||
     221              :       !imgCtx
     222              :     ) {
     223            0 :       console.error('[useCanvasTransform] Canvas contexts not ready')
     224            0 :       return
     225              :     }
     226              : 
     227            0 :     const mirroredMask = mirrorCanvas(maskCtx, maskCanvas, true)
     228            0 :     const mirroredRgb = mirrorCanvas(rgbCtx, rgbCanvas, true)
     229            0 :     const mirroredImg = mirrorCanvas(imgCtx, imgCanvas, true)
     230              : 
     231            0 :     maskCtx.putImageData(mirroredMask, 0, 0)
     232            0 :     rgbCtx.putImageData(mirroredRgb, 0, 0)
     233            0 :     imgCtx.putImageData(mirroredImg, 0, 0)
     234              : 
     235            0 :     if (store.tgpuRoot) {
     236            0 :       await recreateGPUTextures(maskCanvas.width, maskCanvas.height)
     237              :     }
     238              : 
     239            0 :     store.canvasHistory.saveState(mirroredMask, mirroredRgb, mirroredImg)
     240              :   }
     241              : 
     242           31 :   const mirrorVertical = async (): Promise<void> => {
     243            0 :     const { maskCanvas, maskCtx, rgbCanvas, rgbCtx, imgCanvas, imgCtx } = store
     244              : 
     245            0 :     if (
     246              :       !maskCanvas ||
     247              :       !maskCtx ||
     248              :       !rgbCanvas ||
     249              :       !rgbCtx ||
     250              :       !imgCanvas ||
     251              :       !imgCtx
     252              :     ) {
     253            0 :       console.error('[useCanvasTransform] Canvas contexts not ready')
     254            0 :       return
     255              :     }
     256              : 
     257            0 :     const mirroredMask = mirrorCanvas(maskCtx, maskCanvas, false)
     258            0 :     const mirroredRgb = mirrorCanvas(rgbCtx, rgbCanvas, false)
     259            0 :     const mirroredImg = mirrorCanvas(imgCtx, imgCanvas, false)
     260              : 
     261            0 :     maskCtx.putImageData(mirroredMask, 0, 0)
     262            0 :     rgbCtx.putImageData(mirroredRgb, 0, 0)
     263            0 :     imgCtx.putImageData(mirroredImg, 0, 0)
     264              : 
     265            0 :     if (store.tgpuRoot) {
     266            0 :       await recreateGPUTextures(maskCanvas.width, maskCanvas.height)
     267              :     }
     268              : 
     269            0 :     store.canvasHistory.saveState(mirroredMask, mirroredRgb, mirroredImg)
     270              :   }
     271              : 
     272           31 :   return {
     273              :     rotateClockwise,
     274              :     rotateCounterclockwise,
     275              :     mirrorHorizontal,
     276              :     mirrorVertical
     277              :   }
     278              : }
        

Generated by: LCOV version 2.0-1