starmusic-pc

starmusic-pc/ scripts/gen-icons.cjs 25.3 KB · 791 行原始文件
F fqh feat: Star Music PC v1.3.0 首次提交（Wails v2 桌面端） 2 天前
1#!/usr/bin/env node
2/**
* 图标生成器：把源 PNG 转成 Windows 应用图标
*
* 用途：
*   1. 解析源图（仅依赖 Node 内置 zlib，无需 sharp/Pillow/ImageMagick）
*   2. 统一做「圆角方形」处理 —— 源图是对齐满幅的浅色底，直接当图标在任务栏/资源管理器里
*      会是一块生硬的白方块；圆角后视觉上更像一个现代应用图标，且四角透明可与深色任务栏融合
*   3. 生成 build/windows/icon.ico（多尺寸，PNG 条目，与 Wails 模板一致）
*      与 build/appicon.png（1024，供 NSIS 安装包与其它平台使用）
*
* 质量要点：
*   - 缩放使用「面积平均」（可分离两趟：先横后竖）并基于**预乘 alpha**，
*     否则圆角处的半透明边缘会出现灰边/彩边
*   - 面积平均天然带抗锯齿，非整数倍缩放（如 1024→24）也不会出现锯齿跳动
*   - PNG 编码使用自适应滤波（5 种滤波器取绝对差之和最小者），压缩率与画质兼顾
*
* 用法：
*   node scripts/gen-icons.cjs                 # 分析 + 生成
*   node scripts/gen-icons.cjs --analyze       # 仅分析源图
*/
22
23const fs = require('fs')
24const path = require('path')
25const zlib = require('zlib')
26
27// ============================================================
28// 配置
29// ============================================================
30
31const SRC =
process.argv.includes('--src') && process.argv[process.argv.indexOf('--src') + 1]
  ? process.argv[process.argv.indexOf('--src') + 1]
  : 'C:/Users/admin/Documents/HBuilderProjects/starmusic/unpackage/dist/build/app-plus/static/icon/appstore.png'
35
36const PROJECT_ROOT = path.resolve(__dirname, '..')
37const OUT_ICO = path.join(PROJECT_ROOT, 'build', 'windows', 'icon.ico')
38const OUT_APPICON = path.join(PROJECT_ROOT, 'build', 'appicon.png')
39/** 预览图写到 .smoke 目录，避免混进构建产物 */
40const OUT_PREVIEW = path.join(PROJECT_ROOT, '.smoke', 'icon-preview.png')
41
42/** 圆角半径占边长的比例（0 表示不圆角）。22% 接近现代应用图标（iOS/Win11）的观感 */
43const RADIUS_RATIO = 0.22
44
45/**
* 背景清理阈值：与背景色距离 ≤ 该值的像素压成纯背景色（0 = 关闭）。
* 目的是消掉源图底部的柔和投影与噪点 —— 它们在 16~24px 下会退化成灰糊。
*/
49const BG_CLEAN_THRESHOLD = Number(process.env.BG_CLEAN ?? 30)
50
51/** 过渡带宽度：阈值到 阈值+该值 之间线性收敛到背景色，避免出现硬边台阶 */
52const BG_CLEAN_FEATHER = 18
53
54/** ICO 内包含的尺寸：覆盖 100%~200% 各档 DPI 下任务栏/资源管理器用到的像素尺寸 */
55const ICO_SIZES = [256, 128, 96, 64, 48, 40, 32, 24, 20, 16]
56
57/** 圆角遮罩的超采样倍率（4 → 每像素 16 个采样点） */
58const MASK_SAMPLES = 4
59
60const ANALYZE_ONLY = process.argv.includes('--analyze')
61
62// ============================================================
63// PNG 解码（支持 8 位 灰/RGB/索引/RGBA，非隔行）
64// ============================================================
65
66function decodePNG(buf) {
if (buf.readUInt32BE(0) !== 0x89504e47 || buf.readUInt32BE(4) !== 0x0d0a1a0a) {
  throw new Error('不是有效的 PNG 文件')
}
let pos = 8
let width = 0
let height = 0
let bitDepth = 0
let colorType = 0
let interlace = 0
const idat = []
let palette = null
let trns = null
79
while (pos + 8 <= buf.length) {
  const len = buf.readUInt32BE(pos)
  const type = buf.toString('ascii', pos + 4, pos + 8)
  const data = buf.subarray(pos + 8, pos + 8 + len)
  if (type === 'IHDR') {
    width = data.readUInt32BE(0)
    height = data.readUInt32BE(4)
    bitDepth = data[8]
    colorType = data[9]
    interlace = data[12]
  } else if (type === 'IDAT') {
    idat.push(data)
  } else if (type === 'PLTE') {
    palette = Buffer.from(data)
  } else if (type === 'tRNS') {
    trns = Buffer.from(data)
  } else if (type === 'IEND') {
    break
  }
  pos += 12 + len
}
101
if (!width || !height) throw new Error('PNG 缺少 IHDR')
if (bitDepth !== 8) throw new Error(`暂不支持 ${bitDepth} 位深，请提供 8 位深的 PNG`)
if (interlace !== 0) throw new Error('暂不支持 Adam7 隔行扫描，请另存为非隔行 PNG')
105
const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[colorType]
if (!channels) throw new Error(`暂不支持的颜色类型 ${colorType}`)
108
const raw = zlib.inflateSync(Buffer.concat(idat))
const bpp = channels
const stride = width * bpp
const out = Buffer.alloc(height * stride)
113
// 反滤波（PNG 逐行滤波，类型 0~4）
let rp = 0
for (let y = 0; y < height; y++) {
  const ft = raw[rp++]
  const line = raw.subarray(rp, rp + stride)
  rp += stride
  const cur = out.subarray(y * stride, (y + 1) * stride)
  const prev = y > 0 ? out.subarray((y - 1) * stride, y * stride) : null
  for (let x = 0; x < stride; x++) {
    const a = x >= bpp ? cur[x - bpp] : 0
    const b = prev ? prev[x] : 0
    const c = prev && x >= bpp ? prev[x - bpp] : 0
    let v = line[x]
    switch (ft) {
      case 0:
        break
      case 1:
        v = (v + a) & 255
        break
      case 2:
        v = (v + b) & 255
        break
      case 3:
        v = (v + ((a + b) >> 1)) & 255
        break
      case 4: {
        const p = a + b - c
        const pa = Math.abs(p - a)
        const pb = Math.abs(p - b)
        const pc = Math.abs(p - c)
        const pr = pa <= pb && pa <= pc ? a : pb <= pc ? b : c
        v = (v + pr) & 255
        break
      }
      default:
        throw new Error(`未知的滤波类型 ${ft}（第 ${y} 行）`)
    }
    cur[x] = v
  }
}
154
// 统一转成 RGBA
const rgba = new Uint8ClampedArray(width * height * 4)
for (let i = 0, n = width * height; i < n; i++) {
  const s = i * bpp
  const d = i * 4
  switch (colorType) {
    case 6:
      rgba[d] = out[s]
      rgba[d + 1] = out[s + 1]
      rgba[d + 2] = out[s + 2]
      rgba[d + 3] = out[s + 3]
      break
    case 2:
      rgba[d] = out[s]
      rgba[d + 1] = out[s + 1]
      rgba[d + 2] = out[s + 2]
      rgba[d + 3] = 255
      break
    case 0:
      rgba[d] = rgba[d + 1] = rgba[d + 2] = out[s]
      rgba[d + 3] = 255
      break
    case 4:
      rgba[d] = rgba[d + 1] = rgba[d + 2] = out[s]
      rgba[d + 3] = out[s + 1]
      break
    case 3: {
      const idx = out[s] * 3
      rgba[d] = palette[idx]
      rgba[d + 1] = palette[idx + 1]
      rgba[d + 2] = palette[idx + 2]
      rgba[d + 3] = trns && out[s] < trns.length ? trns[out[s]] : 255
      break
    }
  }
}
191
return { width, height, rgba }
193}
194
195// ============================================================
196// PNG 编码（自适应滤波）
197// ============================================================
198
199const CRC_TABLE = (() => {
const t = new Int32Array(256)
for (let n = 0; n < 256; n++) {
  let c = n
  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
  t[n] = c
}
return t
207})()
208
209function crc32(buf) {
let c = -1
for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8)
return (c ^ -1) >>> 0
213}
214
215function chunk(type, data) {
const len = Buffer.alloc(4)
len.writeUInt32BE(data.length, 0)
const typeBuf = Buffer.from(type, 'ascii')
const crc = Buffer.alloc(4)
crc.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0)
return Buffer.concat([len, typeBuf, data, crc])
222}
223
224function paeth(a, b, c) {
const p = a + b - c
const pa = Math.abs(p - a)
const pb = Math.abs(p - b)
const pc = Math.abs(p - c)
return pa <= pb && pa <= pc ? a : pb <= pc ? b : c
230}
231
232function encodePNG(rgba, width, height) {
const stride = width * 4
const raw = Buffer.alloc(height * (stride + 1))
235
for (let y = 0; y < height; y++) {
  const cur = rgba.subarray(y * stride, (y + 1) * stride)
  const prev = y > 0 ? rgba.subarray((y - 1) * stride, y * stride) : null
  const rowStart = y * (stride + 1)
240
  // 依次尝试 5 种滤波，取「绝对差之和」最小者（PNG 通行启发式）
  let bestFilter = 0
  let bestScore = Infinity
  let bestData = null
  const candidates = []
246
  for (let ft = 0; ft <= 4; ft++) {
    const outRow = Buffer.alloc(stride)
    let score = 0
    for (let x = 0; x < stride; x++) {
      const a = x >= 4 ? cur[x - 4] : 0
      const b = prev ? prev[x] : 0
      const c = prev && x >= 4 ? prev[x - 4] : 0
      let v
      switch (ft) {
        case 0:
          v = cur[x]
          break
        case 1:
          v = cur[x] - a
          break
        case 2:
          v = cur[x] - b
          break
        case 3:
          v = cur[x] - ((a + b) >> 1)
          break
        default:
          v = cur[x] - paeth(a, b, c)
          break
      }
      v &= 255
      outRow[x] = v
      // 有符号视角的绝对差更能反映熵
      score += v < 128 ? v : 256 - v
    }
    candidates.push(outRow)
    if (score < bestScore) {
      bestScore = score
      bestFilter = ft
      bestData = outRow
    }
  }
284
  raw[rowStart] = bestFilter
  bestData.copy(raw, rowStart + 1)
}
288
const ihdr = Buffer.alloc(13)
ihdr.writeUInt32BE(width, 0)
ihdr.writeUInt32BE(height, 4)
ihdr[8] = 8 // bit depth
ihdr[9] = 6 // RGBA
ihdr[10] = 0
ihdr[11] = 0
ihdr[12] = 0
297
return Buffer.concat([
  Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
  chunk('IHDR', ihdr),
  chunk('IDAT', zlib.deflateSync(raw, { level: 9 })),
  chunk('IEND', Buffer.alloc(0)),
])
304}
305
306// ============================================================
307// 圆角遮罩
308// ============================================================
309
310/** 点是否落在圆角矩形内（标准 SDF 判定） */
311function insideRoundedRect(px, py, w, h, r) {
const cx = Math.min(Math.max(px, r), w - r)
const cy = Math.min(Math.max(py, r), h - r)
const dx = px - cx
const dy = py - cy
return dx * dx + dy * dy <= r * r
317}
318
319/** 生成 0~1 的圆角覆盖率遮罩（超采样抗锯齿） */
320function buildRoundedMask(w, h, radius) {
const mask = new Float32Array(w * h)
if (radius <= 0) {
  mask.fill(1)
  return mask
}
const total = MASK_SAMPLES * MASK_SAMPLES
for (let y = 0; y < h; y++) {
  for (let x = 0; x < w; x++) {
    let inside = 0
    for (let sy = 0; sy < MASK_SAMPLES; sy++) {
      const py = y + (sy + 0.5) / MASK_SAMPLES
      for (let sx = 0; sx < MASK_SAMPLES; sx++) {
        const px = x + (sx + 0.5) / MASK_SAMPLES
        if (insideRoundedRect(px, py, w, h, radius)) inside++
      }
    }
    mask[y * w + x] = inside / total
  }
}
return mask
341}
342
343// ============================================================
344// 缩放（预乘 alpha 的面积平均，可分离两趟）
345// ============================================================
346
347function resample(src, sw, sh, dw, dh) {
// 横向：sw → dw
const tmp = new Float32Array(dw * sh * 4)
const scaleX = sw / dw
for (let y = 0; y < sh; y++) {
  const rowOff = y * sw * 4
  for (let x = 0; x < dw; x++) {
    const x0 = x * scaleX
    const x1 = (x + 1) * scaleX
    const i0 = Math.floor(x0)
    const i1 = Math.min(sw, Math.ceil(x1))
    let r = 0
    let g = 0
    let b = 0
    let a = 0
    let wsum = 0
    for (let i = i0; i < i1; i++) {
      const cov = Math.min(i + 1, x1) - Math.max(i, x0)
      if (cov <= 0) continue
      const o = rowOff + i * 4
      const al = src[o + 3] / 255
      r += src[o] * al * cov
      g += src[o + 1] * al * cov
      b += src[o + 2] * al * cov
      a += al * cov
      wsum += cov
    }
    const t = (y * dw + x) * 4
    if (wsum > 0) {
      tmp[t] = r / wsum
      tmp[t + 1] = g / wsum
      tmp[t + 2] = b / wsum
      tmp[t + 3] = a / wsum
    }
  }
}
383
// 纵向：sh → dh，并反预乘回 8 位
const out = new Uint8ClampedArray(dw * dh * 4)
const scaleY = sh / dh
for (let y = 0; y < dh; y++) {
  const y0 = y * scaleY
  const y1 = (y + 1) * scaleY
  const j0 = Math.floor(y0)
  const j1 = Math.min(sh, Math.ceil(y1))
  for (let x = 0; x < dw; x++) {
    let r = 0
    let g = 0
    let b = 0
    let a = 0
    let wsum = 0
    for (let j = j0; j < j1; j++) {
      const cov = Math.min(j + 1, y1) - Math.max(j, y0)
      if (cov <= 0) continue
      const o = (j * dw + x) * 4
      r += tmp[o] * cov
      g += tmp[o + 1] * cov
      b += tmp[o + 2] * cov
      a += tmp[o + 3] * cov
      wsum += cov
    }
    const d = (y * dw + x) * 4
    if (wsum > 0 && a / wsum > 0.0001) {
      const av = a / wsum
      out[d] = Math.round(r / wsum / av)
      out[d + 1] = Math.round(g / wsum / av)
      out[d + 2] = Math.round(b / wsum / av)
      out[d + 3] = Math.round(av * 255)
    } else {
      out[d] = out[d + 1] = out[d + 2] = out[d + 3] = 0
    }
  }
}
return out
421}
422
423// ============================================================
424// ICO 打包（全部使用 PNG 条目，与 Wails 模板一致）
425// ============================================================
426
427function buildICO(entries) {
const header = Buffer.alloc(6)
header.writeUInt16LE(0, 0) // reserved
header.writeUInt16LE(1, 2) // type = icon
header.writeUInt16LE(entries.length, 4)
432
const dir = Buffer.alloc(16 * entries.length)
let offset = 6 + 16 * entries.length
entries.forEach((e, i) => {
  const o = i * 16
  dir[o] = e.size >= 256 ? 0 : e.size // 256 用 0 表示
  dir[o + 1] = e.size >= 256 ? 0 : e.size
  dir[o + 2] = 0 // 调色板数
  dir[o + 3] = 0 // reserved
  dir.writeUInt16LE(1, o + 4) // color planes
  dir.writeUInt16LE(32, o + 6) // bits per pixel
  dir.writeUInt32LE(e.png.length, o + 8)
  dir.writeUInt32LE(offset, o + 12)
  offset += e.png.length
})
447
return Buffer.concat([header, dir, ...entries.map((e) => e.png)])
449}
450
451/** 取四角像素均值作为背景色估计 */
452function estimateBackground(rgba, w, h) {
const px = (x, y) => {
  const o = (y * w + x) * 4
  return [rgba[o], rgba[o + 1], rgba[o + 2]]
}
const corners = [px(0, 0), px(w - 1, 0), px(0, h - 1), px(w - 1, h - 1)]
return [0, 1, 2].map((i) => Math.round(corners.reduce((s, c) => s + c[i], 0) / corners.length))
459}
460
461// ============================================================
462// 背景清理
463// ============================================================
464
465/**
* 把「接近背景色」的像素压成纯背景色。
*
* 为什么需要：源图底部有一层柔和投影、整体也带轻微噪点。这些微弱差异在 256px 下几乎看不出来，
* 但缩到 16~24px 时会退化成一层灰糊，削弱主体轮廓。阈值只覆盖「弱差异」区域，
* 笔画的抗锯齿边缘（与背景差异很大）不受影响。
*
* @param {Uint8ClampedArray} rgba
* @param {number[]} bg 背景色 [r,g,b]
* @param {number} threshold 距离阈值；<=0 表示关闭
* @param {number} feather 过渡上限：距离在 (threshold, feather] 之间的像素按比例向背景色收敛，避免出现硬边
*/
477function cleanBackground(rgba, bg, threshold, feather) {
if (threshold <= 0) return rgba
const out = new Uint8ClampedArray(rgba.length)
const hi = Math.max(threshold + 1, feather)
for (let i = 0; i < rgba.length; i += 4) {
  const r = rgba[i]
  const g = rgba[i + 1]
  const b = rgba[i + 2]
  const d = Math.sqrt((r - bg[0]) ** 2 + (g - bg[1]) ** 2 + (b - bg[2]) ** 2)
  if (d <= threshold) {
    out[i] = bg[0]
    out[i + 1] = bg[1]
    out[i + 2] = bg[2]
  } else if (d < hi) {
    // 过渡带：线性插值到背景，避免阈值处出现生硬台阶
    const t = (d - threshold) / (hi - threshold)
    out[i] = Math.round(bg[0] + (r - bg[0]) * t)
    out[i + 1] = Math.round(bg[1] + (g - bg[1]) * t)
    out[i + 2] = Math.round(bg[2] + (b - bg[2]) * t)
  } else {
    out[i] = r
    out[i + 1] = g
    out[i + 2] = b
  }
  out[i + 3] = rgba[i + 3]
}
return out
504}
505
506// ============================================================
507// 预览图：把关键尺寸放大后排布在浅/深两种背景上，用于人工校验可读性
508// ============================================================
509
510/** 最近邻放大（保留像素块，便于判断小尺寸是否糊成一团） */
511function nearestScale(src, sw, sh, factor) {
const dw = sw * factor
const dh = sh * factor
const out = new Uint8ClampedArray(dw * dh * 4)
for (let y = 0; y < dh; y++) {
  const sy = Math.min(sh - 1, Math.floor(y / factor))
  for (let x = 0; x < dw; x++) {
    const sx = Math.min(sw - 1, Math.floor(x / factor))
    const s = (sy * sw + sx) * 4
    const d = (y * dw + x) * 4
    out[d] = src[s]
    out[d + 1] = src[s + 1]
    out[d + 2] = src[s + 2]
    out[d + 3] = src[s + 3]
  }
}
return { rgba: out, width: dw, height: dh }
528}
529
530/** 半尺寸最近邻（用于把 256 缩到 128 展示） */
531function halfScale(src, sw, sh) {
const dw = sw >> 1
const dh = sh >> 1
const out = new Uint8ClampedArray(dw * dh * 4)
for (let y = 0; y < dh; y++) {
  for (let x = 0; x < dw; x++) {
    const s = ((y * 2) * sw + x * 2) * 4
    const d = (y * dw + x) * 4
    out[d] = src[s]
    out[d + 1] = src[s + 1]
    out[d + 2] = src[s + 2]
    out[d + 3] = src[s + 3]
  }
}
return { rgba: out, width: dw, height: dh }
546}
547
548/** alpha 合成：把 src 叠加到纯色背景上 */
549function overSolid(src, bg) {
const out = new Uint8ClampedArray(src.length)
for (let i = 0; i < src.length; i += 4) {
  const a = src[i + 3] / 255
  out[i] = Math.round(src[i] * a + bg[0] * (1 - a))
  out[i + 1] = Math.round(src[i + 1] * a + bg[1] * (1 - a))
  out[i + 2] = Math.round(src[i + 2] * a + bg[2] * (1 - a))
  out[i + 3] = 255
}
return out
559}
560
561/**
* 生成预览图：三列分别展示 16px(×8) / 32px(×4) / 256px(×0.5)，
* 上行浅色背景、下行深色背景，用于同时校验两种使用场景。
*/
565function buildPreview(masked, sw, sh) {
const CELL = 128
const PAD = 20
const cols = 3
const W = cols * CELL + (cols + 1) * PAD
const H = 2 * CELL + 3 * PAD
const canvas = new Uint8ClampedArray(W * H * 4)
572
const paintBg = (y0, y1, rgb) => {
  for (let y = y0; y < y1; y++) {
    for (let x = 0; x < W; x++) {
      const o = (y * W + x) * 4
      canvas[o] = rgb[0]
      canvas[o + 1] = rgb[1]
      canvas[o + 2] = rgb[2]
      canvas[o + 3] = 255
    }
  }
}
// 上半浅灰、下半近黑（模拟 Windows 浅色/深色任务栏）
paintBg(0, Math.floor(H / 2), [242, 244, 246])
paintBg(Math.floor(H / 2), H, [26, 30, 36])
587
const blit = (src, dw, dh, x0, y0, bg) => {
  const composited = overSolid(src, bg)
  for (let y = 0; y < dh; y++) {
    for (let x = 0; x < dw; x++) {
      const ty = y0 + y
      const tx = x0 + x
      if (ty < 0 || ty >= H || tx < 0 || tx >= W) continue
      const s = (y * dw + x) * 4
      const d = (ty * W + tx) * 4
      canvas[d] = composited[s]
      canvas[d + 1] = composited[s + 1]
      canvas[d + 2] = composited[s + 2]
      canvas[d + 3] = 255
    }
  }
}
604
const rowBg = [
  [242, 244, 246],
  [26, 30, 36],
]
609
// 各列：(目标展示尺寸, 缩放方式)
const plan = [
  { draw: 16, mode: 'up', factor: 8 },
  { draw: 32, mode: 'up', factor: 4 },
  { draw: 256, mode: 'half' },
]
616
plan.forEach((p, ci) => {
  let rendered
  if (p.mode === 'up') {
    const base = resample(masked, sw, sh, p.draw, p.draw)
    rendered = nearestScale(base, p.draw, p.draw, p.factor)
  } else {
    const base = resample(masked, sw, sh, p.draw, p.draw)
    rendered = halfScale(base, p.draw, p.draw)
  }
  rowBg.forEach((bg, ri) => {
    const x0 = PAD + ci * (CELL + PAD)
    const y0 = PAD + ri * (CELL + PAD)
    blit(rendered.rgba, rendered.width, rendered.height, x0, y0, bg)
  })
})
632
return { rgba: canvas, width: W, height: H }
634}
635
636// ============================================================
637// 源图分析
638// ============================================================
639
640function analyze(rgba, w, h) {
const px = (x, y) => {
  const o = (y * w + x) * 4
  return [rgba[o], rgba[o + 1], rgba[o + 2], rgba[o + 3]]
}
const corners = {
  左上: px(0, 0),
  右上: px(w - 1, 0),
  左下: px(0, h - 1),
  右下: px(w - 1, h - 1),
}
console.log('--- 源图分析 ---')
for (const [k, v] of Object.entries(corners)) {
  console.log(`  ${k}角 rgba = ${v.join(',')}`)
}
655
// 四边中点的 alpha，判断是否满幅不透明
const edgeMid = {
  上边: px(Math.floor(w / 2), 0),
  下边: px(Math.floor(w / 2), h - 1),
  左边: px(0, Math.floor(h / 2)),
  右边: px(w - 1, Math.floor(h / 2)),
}
for (const [k, v] of Object.entries(edgeMid)) {
  console.log(`  ${k}中点 rgba = ${v.join(',')}`)
}
666
// 透明像素占比
let transparent = 0
let opaque = 0
for (let i = 0; i < w * h; i++) {
  const a = rgba[i * 4 + 3]
  if (a < 8) transparent++
  else if (a > 247) opaque++
}
const total = w * h
console.log(
  `  完全透明像素 ${((transparent / total) * 100).toFixed(1)}% · 完全不透明 ${((opaque / total) * 100).toFixed(1)}%`
)
console.log(`  四角 alpha 全为 255 → 背景是**不透明**的，必须圆角裁切，否则图标会是硬边白方块`)
680
// 背景色取四角均值
const bg = estimateBackground(rgba, w, h)
console.log(`  推定背景色 rgb(${bg.join(',')})`)
684
// 内容包围盒（与背景色差异超过阈值的像素）
for (const threshold of [40, 70]) {
  let x0 = w
  let y0 = h
  let x1 = -1
  let y1 = -1
  for (let y = 0; y < h; y++) {
    for (let x = 0; x < w; x++) {
      const o = (y * w + x) * 4
      const d = Math.sqrt(
        (rgba[o] - bg[0]) ** 2 + (rgba[o + 1] - bg[1]) ** 2 + (rgba[o + 2] - bg[2]) ** 2
      )
      if (d > threshold) {
        if (x < x0) x0 = x
        if (x > x1) x1 = x
        if (y < y0) y0 = y
        if (y > y1) y1 = y
      }
    }
  }
  if (x1 < 0) {
    console.log(`  阈值 ${threshold}：未找到内容`)
    continue
  }
  const cw = x1 - x0 + 1
  const ch = y1 - y0 + 1
  console.log(
    `  阈值 ${String(threshold).padStart(2)}：内容 ${cw}×${ch} @ (${x0},${y0})  ` +
      `占画幅 ${((cw / w) * 100).toFixed(1)}% × ${((ch / h) * 100).toFixed(1)}%  ` +
      `四周留白 左${x0} 上${y0} 右${w - x1 - 1} 下${h - y1 - 1}`
  )
}
console.log('')
718}
719
720// ============================================================
721// 主流程
722// ============================================================
723
724function main() {
if (!fs.existsSync(SRC)) throw new Error(`源文件不存在：${SRC}`)
console.log('源文件：' + SRC)
727
const t0 = Date.now()
const src = decodePNG(fs.readFileSync(SRC))
console.log(`已解码：${src.width}×${src.height}，耗时 ${Date.now() - t0}ms\n`)
731
analyze(src.rgba, src.width, src.height)
if (ANALYZE_ONLY) return
734
// 1. 清掉柔和投影/噪点 → 再做圆角遮罩 → 最后缩放
const bg = estimateBackground(src.rgba, src.width, src.height)
const cleaned = cleanBackground(src.rgba, bg, BG_CLEAN_THRESHOLD, BG_CLEAN_THRESHOLD + BG_CLEAN_FEATHER)
console.log(
  BG_CLEAN_THRESHOLD > 0
    ? `背景清理：与 rgb(${bg.join(',')}) 距离 ≤ ${BG_CLEAN_THRESHOLD} 的像素压为纯背景色（过渡带 ${BG_CLEAN_FEATHER}）`
    : '背景清理：已关闭'
)
743
const radius = Math.round(Math.min(src.width, src.height) * RADIUS_RATIO)
console.log(`圆角半径：${radius}px（源尺寸的 ${(RADIUS_RATIO * 100).toFixed(0)}%）`)
const mask = buildRoundedMask(src.width, src.height, radius)
const masked = new Uint8ClampedArray(cleaned.length)
for (let i = 0; i < src.width * src.height; i++) {
  const o = i * 4
  masked[o] = cleaned[o]
  masked[o + 1] = cleaned[o + 1]
  masked[o + 2] = cleaned[o + 2]
  masked[o + 3] = cleaned[o + 3] * mask[i]
}
755
// 2. 生成 ICO
const entries = []
for (const size of ICO_SIZES) {
  const t = Date.now()
  const scaled = resample(masked, src.width, src.height, size, size)
  const png = encodePNG(scaled, size, size)
  entries.push({ size, png })
  console.log(`  ${String(size).padStart(3)}×${String(size).padEnd(3)}  PNG ${String(png.length).padStart(6)} B  (${Date.now() - t}ms)`)
}
const ico = buildICO(entries)
fs.mkdirSync(path.dirname(OUT_ICO), { recursive: true })
fs.writeFileSync(OUT_ICO, ico)
console.log(`\n✔ 已写出 ${OUT_ICO}  共 ${entries.length} 档尺寸，${(ico.length / 1024).toFixed(1)} KB`)
769
// 3. 生成 appicon.png（1024，供 NSIS / 其它平台使用）
const appIconSize = 1024
const appScaled =
  src.width === appIconSize
    ? masked
    : resample(masked, src.width, src.height, appIconSize, appIconSize)
const appPng = encodePNG(appScaled, appIconSize, appIconSize)
fs.mkdirSync(path.dirname(OUT_APPICON), { recursive: true })
fs.writeFileSync(OUT_APPICON, appPng)
console.log(`✔ 已写出 ${OUT_APPICON}  1024×1024  ${(appPng.length / 1024).toFixed(1)} KB`)
780
// 4. 预览图（浅色行 / 深色行各三档关键尺寸）
const preview = buildPreview(masked, src.width, src.height)
const previewPng = encodePNG(preview.rgba, preview.width, preview.height)
fs.mkdirSync(path.dirname(OUT_PREVIEW), { recursive: true })
fs.writeFileSync(OUT_PREVIEW, previewPng)
console.log(`✔ 已写出 ${OUT_PREVIEW}  预览：16px×8 / 32px×4 / 256px×0.5，上浅下深`)
787
console.log(`\n总耗时 ${Date.now() - t0}ms`)
789}
790
791main()