LCOV - code coverage report
Current view: top level - packages/viewport3d/src/load3d - modelStats.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 87.3 % 63 55
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import * as THREE from 'three'
       2              : 
       3              : export interface ModelStats {
       4              :   vertices: number
       5              :   edges: number
       6              :   triangles: number
       7              : }
       8              : 
       9           24 : const EMPTY_STATS: ModelStats = {
      10              :   vertices: 0,
      11              :   edges: 0,
      12              :   triangles: 0
      13              : }
      14              : 
      15           24 : const CHUNK_SIZE = 50_000
      16              : 
      17            0 : async function yieldToEventLoop(signal?: AbortSignal): Promise<void> {
      18            0 :   await new Promise<void>((resolve) => setTimeout(resolve, 0))
      19            0 :   signal?.throwIfAborted()
      20              : }
      21              : 
      22           17 : async function weldByPosition(
      23              :   position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute,
      24              :   signal?: AbortSignal
      25              : ): Promise<{ remap: Uint32Array; uniqueCount: number }> {
      26           17 :   const ids = new Map<string, number>()
      27           17 :   const remap = new Uint32Array(position.count)
      28           17 :   for (let i = 0; i < position.count; i++) {
      29          546 :     if (i > 0 && i % CHUNK_SIZE === 0) await yieldToEventLoop(signal)
      30          546 :     const key = `${position.getX(i)},${position.getY(i)},${position.getZ(i)}`
      31          546 :     const existing = ids.get(key)
      32          546 :     if (existing === undefined) {
      33          126 :       remap[i] = ids.size
      34          126 :       ids.set(key, ids.size)
      35              :     } else {
      36          420 :       remap[i] = existing
      37              :     }
      38              :   }
      39           17 :   return { remap, uniqueCount: ids.size }
      40              : }
      41              : 
      42           17 : async function countTopology(
      43              :   cornerIndices: ArrayLike<number>,
      44              :   remap: Uint32Array,
      45              :   vertexCount: number,
      46              :   signal?: AbortSignal
      47              : ): Promise<{ edges: number; triangles: number }> {
      48           17 :   const edges = new Set<number>()
      49           17 :   const triangles = new Set<string>()
      50           17 :   const cornerTriangles = Math.floor(cornerIndices.length / 3)
      51           17 :   for (let t = 0; t < cornerTriangles; t++) {
      52          182 :     if (t > 0 && t % CHUNK_SIZE === 0) await yieldToEventLoop(signal)
      53          182 :     const corners = [
      54              :       remap[cornerIndices[t * 3]],
      55              :       remap[cornerIndices[t * 3 + 1]],
      56              :       remap[cornerIndices[t * 3 + 2]]
      57              :     ].sort((a, b) => a - b)
      58          182 :     const [a, b, c] = corners
      59              :     const isDegenerate = a === b || b === c
      60          182 :     if (isDegenerate) continue
      61          182 :     const triangleKey = corners.join(',')
      62          182 :     if (triangles.has(triangleKey)) continue
      63          182 :     triangles.add(triangleKey)
      64          182 :     edges.add(a * vertexCount + b)
      65          182 :     edges.add(b * vertexCount + c)
      66          182 :     edges.add(a * vertexCount + c)
      67              :   }
      68          182 :   return { edges: edges.size, triangles: triangles.size }
      69              : }
      70              : 
      71           17 : function sequentialCorners(count: number): Uint32Array {
      72           17 :   return Uint32Array.from({ length: count }, (_, i) => i)
      73              : }
      74              : 
      75           17 : async function meshStats(
      76              :   mesh: THREE.Mesh,
      77              :   signal?: AbortSignal
      78              : ): Promise<ModelStats> {
      79           17 :   if (!mesh.geometry.hasAttribute('position')) return EMPTY_STATS
      80              :   const position = mesh.geometry.getAttribute('position')
      81              : 
      82           17 :   const { remap, uniqueCount } = await weldByPosition(position, signal)
      83              :   const corners = mesh.geometry.index?.array ?? sequentialCorners(remap.length)
      84           17 :   const { edges, triangles } = await countTopology(
      85              :     corners,
      86              :     remap,
      87              :     uniqueCount,
      88              :     signal
      89              :   )
      90           17 :   const instances = mesh instanceof THREE.InstancedMesh ? mesh.count : 1
      91              : 
      92           17 :   return {
      93              :     vertices: uniqueCount * instances,
      94              :     edges: edges * instances,
      95              :     triangles: triangles * instances
      96              :   }
      97              : }
      98              : 
      99            0 : function pointsStats(points: THREE.Points): ModelStats {
     100            0 :   const { geometry } = points
     101            0 :   const vertices = geometry.hasAttribute('position')
     102              :     ? geometry.getAttribute('position').count
     103              :     : 0
     104            0 :   return { ...EMPTY_STATS, vertices }
     105              : }
     106              : 
     107           17 : function addStats(a: ModelStats, b: ModelStats): ModelStats {
     108           17 :   return {
     109              :     vertices: a.vertices + b.vertices,
     110              :     edges: a.edges + b.edges,
     111              :     triangles: a.triangles + b.triangles
     112              :   }
     113              : }
     114              : 
     115           17 : export async function computeModelStats(
     116              :   root: THREE.Object3D,
     117              :   signal?: AbortSignal
     118              : ): Promise<ModelStats> {
     119           17 :   signal?.throwIfAborted()
     120           17 :   const meshes: THREE.Mesh[] = []
     121           17 :   let total = EMPTY_STATS
     122           17 :   root.traverse((child) => {
     123           34 :     if (child instanceof THREE.Mesh) {
     124           17 :       meshes.push(child)
     125           17 :     } else if (child instanceof THREE.Points) {
     126            0 :       total = addStats(total, pointsStats(child))
     127              :     }
     128              :   })
     129           17 :   for (const mesh of meshes) {
     130           17 :     const stats = await meshStats(mesh, signal)
     131           17 :     signal?.throwIfAborted()
     132           17 :     total = addStats(total, stats)
     133              :   }
     134           17 :   return total
     135              : }
     136              : 
     137           18 : export function hasGeometry(stats: ModelStats): boolean {
     138           18 :   return stats.vertices > 0
     139              : }
        

Generated by: LCOV version 2.0-1