Wechat Red Envelope Cover Designer

#!/usr/bin/env node
/*
基于NanoBananaPro/Gemini 3 Pro的图片生成与编辑脚本（Node.js版）
使用API易国内代理服务

支持功能：
- 文生图：根据提示词生成图片
- 图生图：根据编辑指令修改已有图片

参数说明：
- -p, --prompt        图片描述或编辑指令文本（必需）
- -f, --filename      输出图片路径（可选，默认自动生成时间戳文件名）
- -a, --aspect-ratio  图片比例（可选）
- -r, --resolution    图片分辨率（可选：1K/2K/4K，必须大写）
- -i, --input-image   输入图片路径（可选，可多张，最多14张）
- -k, --api-key       API密钥（可选，覆盖环境变量 APIYI_API_KEY）

使用示例：
【生成新图片】
  node generate_image.js -p "一只可爱的橘猫"
  node generate_image.js -p "日落山脉" -a 16:9 -r 4K
  node generate_image.js -p "城市夜景" -a 9:16 -r 2K -f wallpaper.png

【编辑已有图片】
  node generate_image.js -p "转换成油画风格" -i original.png
  node generate_image.js -p "添加彩虹到天空" -i photo.jpg -f edited.png
  node generate_image.js -p "将背景换成海滩" -i portrait.png -a 3:4 -r 2K
  node generate_image.js -p "参考多张图片融合风格" -i ref1.png ref2.png ref3.png -f merged.png

【环境变量】
  export APIYI_API_KEY="your-api-key"
*/

const fs = require('fs');
const path = require('path');
const https = require('https');

const SUPPORTED_ASPECT_RATIOS = [
  '1:1',
  '16:9',
  '9:16',
  '4:3',
  '3:4',
  '3:2',
  '2:3',
  '5:4',
  '4:5',
  '21:9',
];

const SUPPORTED_RESOLUTIONS = ['1K', '2K', '4K'];

function printHelpAndExit(exitCode = 0) {
  const help = `usage: generate_image.js [-h] --prompt PROMPT [--filename FILENAME]
                        [--aspect-ratio ${SUPPORTED_ASPECT_RATIOS.join(', ')}]
                        [--resolution ${SUPPORTED_RESOLUTIONS.join(', ')}]
                        [--input-image INPUT_IMAGE [INPUT_IMAGE ...]]
                        [--api-key API_KEY]

基于Gemini 3 Pro的图片生成与编辑工具（Node.js版）

options:
  -h, --help            show this help message and exit
  -p, --prompt PROMPT   图片描述或编辑指令文本（必需）
  -f, --filename FILE   输出图片路径 (默认: 自动生成时间戳文件名)
  -a, --aspect-ratio    图片比例 (可选)
  -r, --resolution      图片分辨率 (可选: 1K, 2K, 4K，必须大写)
  -i, --input-image     输入图片路径（编辑模式，可传多张，最多14张）
  -k, --api-key         API密钥（覆盖环境变量）

运行示例:
  node scripts/generate_image.js -p "一只可爱的橘猫"
  node scripts/generate_image.js -p "日落山脉" -a 16:9 -r 4K
  node scripts/generate_image.js -p "城市夜景" -a 9:16 -r 2K -f wallpaper.png

  node scripts/generate_image.js -p "转换成油画风格" -i original.png
  node scripts/generate_image.js -p "参考多张图片融合风格" -i ref1.png ref2.png -f merged.png
`;
  process.stdout.write(help);
  process.exit(exitCode);
}

function exitWithError(message) {
  process.stderr.write(`${message}\n`);
  process.exit(1);
}

function pad2(n) {
  return String(n).padStart(2, '0');
}

function formatTimestamp(dateObj) {
  const d = dateObj || new Date();
  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}-${pad2(d.getHours())}-${pad2(d.getMinutes())}-${pad2(d.getSeconds())}`;
}

function addTimestampToFilename(filePath, timestamp) {
  const ts = timestamp || formatTimestamp(new Date());
  const parsed = path.parse(filePath);
  const base = parsed.name ? `${parsed.name}-${ts}` : ts;
  return path.join(parsed.dir || '.', `${base}${parsed.ext || ''}`);
}

function generateFilename(prompt) {
  const now = new Date();
  const timestamp = formatTimestamp(now);

  const keywords = String(prompt).split(/\s+/).filter(Boolean).slice(0, 3);
  const keywordStrRaw = keywords.join('-') || 'image';

  const keywordStr = keywordStrRaw
    .split('')
    .map((c) => (/^[a-zA-Z0-9\-_.]$/.test(c) ? c : '-'))
    .join('')
    .toLowerCase()
    .slice(0, 30);

  return `${timestamp}-${keywordStr}.png`;
}

function getApiKey(argsKey) {
  if (argsKey) return argsKey;
  const apiKey = process.env.APIYI_API_KEY;
  if (!apiKey) {
    exitWithError(
      '错误: 未设置 APIYI_API_KEY 环境变量\n' +
        '请前往 https://api.apiyi.com 注册申请API Key\n' +
        '或使用 -k/--api-key 参数临时指定'
    );
  }
  return apiKey;
}

function encodeImageToBase64(imagePath) {
  try {
    const bytes = fs.readFileSync(imagePath);
    return bytes.toString('base64');
  } catch (e) {
    exitWithError(`错误: 无法读取图片文件 ${imagePath} - ${e.message || String(e)}`);
  }
}

function postJson(urlString, headers, payload, timeoutMs) {
  return new Promise((resolve, reject) => {
    const url = new URL(urlString);

    const body = Buffer.from(JSON.stringify(payload), 'utf8');
    const req = https.request(
      {
        protocol: url.protocol,
        hostname: url.hostname,
        port: url.port || 443,
        path: url.pathname + url.search,
        method: 'POST',
        headers: {
          ...headers,
          'Content-Length': body.length,
        },
      },
      (res) => {
        const chunks = [];
        res.on('data', (d) => chunks.push(d));
        res.on('end', () => {
          const text = Buffer.concat(chunks).toString('utf8');
          const statusCode = res.statusCode || 0;

          if (statusCode < 200 || statusCode >= 300) {
            const err = new Error(`HTTP ${statusCode}`);
            err.statusCode = statusCode;
            err.responseText = text;
            return reject(err);
          }

          try {
            resolve(JSON.parse(text));
          } catch (e) {
            const err = new Error('响应不是有效的JSON');
            err.responseText = text;
            return reject(err);
          }
        });
      }
    );

    req.on('error', reject);

    req.setTimeout(timeoutMs, () => {
      req.destroy(new Error('timeout'));
    });

    req.write(body);
    req.end();
  });
}

function parseArgs(argv) {
  const args = {
    prompt: null,
    filename: null,
    aspectRatio: null,
    resolution: null,
    inputImages: null,
    apiKey: null,
  };

  const knownFlags = new Set([
    '-h',
    '--help',
    '-p',
    '--prompt',
    '-f',
    '--filename',
    '-a',
    '--aspect-ratio',
    '-r',
    '--resolution',
    '-i',
    '--input-image',
    '-k',
    '--api-key',
  ]);

  function requireValue(i, flag) {
    const v = argv[i + 1];
    if (!v || (v.startsWith('-') && knownFlags.has(v))) {
      exitWithError(`错误: 参数 ${flag} 需要一个值`);
    }
    return v;
  }

  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];

    if (a === '-h' || a === '--help') {
      printHelpAndExit(0);
    }

    if (a === '-p' || a === '--prompt') {
      args.prompt = requireValue(i, a);
      i++;
      continue;
    }

    if (a === '-f' || a === '--filename') {
      args.filename = requireValue(i, a);
      i++;
      continue;
    }

    if (a === '-a' || a === '--aspect-ratio') {
      args.aspectRatio = requireValue(i, a);
      i++;
      continue;
    }

    if (a === '-r' || a === '--resolution') {
      args.resolution = requireValue(i, a);
      i++;
      continue;
    }

    if (a === '-k' || a === '--api-key') {
      args.apiKey = requireValue(i, a);
      i++;
      continue;
    }

    if (a === '-i' || a === '--input-image') {
      const images = [];
      let j = i + 1;
      while (j < argv.length) {
        const v = argv[j];
        if (v.startsWith('-') && knownFlags.has(v)) break;
        images.push(v);
        j++;
      }
      if (images.length === 0) {
        exitWithError(`错误: 参数 ${a} 需要至少一个图片路径`);
      }
      args.inputImages = images;
      i = j - 1;
      continue;
    }

    if (a.startsWith('-')) {
      exitWithError(`错误: 未知参数 ${a}，请使用 --help 查看帮助`);
    }
  }

  if (!args.prompt) {
    exitWithError('错误: 缺少必需参数 -p/--prompt');
  }

  return args;
}

async function main() {
  const argv = process.argv.slice(2);
  const args = parseArgs(argv);

  const runTimestamp = formatTimestamp(new Date());

  let checkProgress = null;
  const clearProgressTimer = () => {
    if (checkProgress) {
      clearInterval(checkProgress);
      checkProgress = null;
    }
  };

  if (args.aspectRatio != null && !SUPPORTED_ASPECT_RATIOS.includes(args.aspectRatio)) {
    exitWithError(
      `错误: 不支持的比例 '${args.aspectRatio}'\n支持的比例: ${SUPPORTED_ASPECT_RATIOS.join(', ')}`
    );
  }

  if (args.resolution != null && !SUPPORTED_RESOLUTIONS.includes(args.resolution)) {
    exitWithError(
      `错误: 不支持的分辨率 '${args.resolution}'\n支持的分辨率: ${SUPPORTED_RESOLUTIONS.join(', ')} (必须大写)`
    );
  }

  if (!args.filename) {
    args.filename = generateFilename(args.prompt);
  } else {
    const resolved = path.resolve(args.filename);
    if (fs.existsSync(resolved)) {
      const adjusted = addTimestampToFilename(args.filename, runTimestamp);
      process.stdout.write(`⚠️ 输出文件已存在，将避免覆盖并改为: ${adjusted}\n`);
      args.filename = adjusted;
    }
  }

  const apiKey = getApiKey(args.apiKey);
  const url =
    'https://api.apiyi.com/v1beta/models/gemini-3-pro-image-preview:generateContent';

  const headers = {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  };

  const parts = [{ text: args.prompt }];
  let modeStr = '生成图片';

  if (args.inputImages && args.inputImages.length > 0) {
    if (args.inputImages.length > 14) {
      exitWithError(`错误: 输入图片最多支持14张，当前为 ${args.inputImages.length} 张`);
    }

    for (const imgPath of args.inputImages) {
      if (!fs.existsSync(imgPath)) {
        exitWithError(`错误: 输入图片不存在: ${imgPath}`);
      }
      const imageBase64 = encodeImageToBase64(imgPath);
      parts.push({
        inlineData: {
          mimeType: 'image/png',
          data: imageBase64,
        },
      });
    }
    modeStr = '编辑图片';
  }

  const generationConfig = {
    responseModalities: ['IMAGE'],
  };

  const imageConfig = {};
  if (args.aspectRatio != null) imageConfig.aspectRatio = args.aspectRatio;
  if (args.resolution != null) imageConfig.imageSize = args.resolution;
  if (Object.keys(imageConfig).length > 0) generationConfig.imageConfig = imageConfig;

  const payload = {
    contents: [{ parts }],
    generationConfig,
  };

  // 生成前通知 + 生成中实时日志（避免长时间无输出导致体验不佳）
  const resolutionHint = args.resolution;
  const etaText = resolutionHint === '4K' ? '1-6分钟' : '30-120秒';
  process.stdout.write('🎨 图片生成已启动！\n');
  process.stdout.write(`⏱️ 预计时间: ${etaText}\n`);
  process.stdout.write('📊 我会定期给您发送进度更新\n');

  process.stdout.write(`正在${modeStr}...\n`);
  process.stdout.write(`提示词: ${args.prompt}\n`);

  if (generationConfig.imageConfig && generationConfig.imageConfig.aspectRatio) {
    process.stdout.write(`比例: ${generationConfig.imageConfig.aspectRatio}\n`);
  }
  if (generationConfig.imageConfig && generationConfig.imageConfig.imageSize) {
    process.stdout.write(`分辨率: ${generationConfig.imageConfig.imageSize}\n`);
  }

  // 输出请求参数（脱敏：不直接输出base64图片数据，避免刷屏）
  const payloadLog = {
    generationConfig,
    contents: [],
  };

  for (const content of payload.contents || []) {
    const partsLog = [];
    for (const part of content.parts || []) {
      if (part && typeof part === 'object' && part.inlineData && typeof part.inlineData === 'object') {
        const inlineData = { ...part.inlineData };
        if (typeof inlineData.data === 'string') {
          inlineData.data = `<omitted base64: ${inlineData.data.length} chars>`;
        }
        partsLog.push({ inlineData });
      } else {
        partsLog.push(part);
      }
    }
    payloadLog.contents.push({ parts: partsLog });
  }

  process.stdout.write(`输出请求参数: ${JSON.stringify(payloadLog, null, 2)}\n`);
  process.stdout.write('image generation in progress...\n');

  const startTime = Date.now();
  checkProgress = setInterval(() => {
    const elapsed = Math.floor((Date.now() - startTime) / 1000);
    process.stdout.write(`🔄 已进行 ${elapsed}秒...\n`);
  }, 5000);

  let data;
  try {
    data = await postJson(url, headers, payload, 120_000);
  } catch (e) {
    clearProgressTimer();
    if (e && e.message === 'timeout') {
      exitWithError('错误: 请求超时，请稍后重试');
    }

    if (e && e.statusCode) {
      process.stderr.write(`错误: 请求失败 - HTTP ${e.statusCode}\n`);
      if (e.responseText) {
        try {
          const detail = JSON.parse(e.responseText);
          process.stderr.write(`错误详情: ${JSON.stringify(detail, null, 2)}\n`);
        } catch {
          process.stderr.write(`响应内容: ${e.responseText}\n`);
        }
      }
      process.exit(1);
    }

    exitWithError(`错误: 请求失败 - ${e.message || String(e)}`);
  }

  clearProgressTimer();

  const imageData =
    data &&
    data.candidates &&
    Array.isArray(data.candidates) &&
    data.candidates[0] &&
    data.candidates[0].content &&
    data.candidates[0].content.parts &&
    data.candidates[0].content.parts[0] &&
    data.candidates[0].content.parts[0].inlineData &&
    data.candidates[0].content.parts[0].inlineData.data;

  if (!imageData) {
    process.stderr.write('错误: 响应中未找到图片数据\n');
    process.stderr.write(`完整响应: ${JSON.stringify(data, null, 2)}\n`);
    process.exit(1);
  }

  const imageBytes = Buffer.from(imageData, 'base64');
  const outputFile = path.resolve(args.filename);
  const outputDir = path.dirname(outputFile);

  fs.mkdirSync(outputDir, { recursive: true });
  fs.writeFileSync(outputFile, imageBytes);

  process.stdout.write(`✓ 图片已成功${modeStr}并保存到: ${args.filename}\n`);
  process.stdout.write('✅ 生成完成！\n');
}

main().catch((e) => {
  exitWithError(`错误: ${e && e.message ? e.message : String(e)}`);
});

{
  "name": "wechat-red-envelope-resize",
  "version": "1.0.0",
  "description": "微信红包封面图片尺寸裁剪工具 - 支持封面图、封面挂件、气泡挂件、封面故事的尺寸转换",
  "main": "resize_cover.js",
  "scripts": {
    "resize": "node resize_cover.js"
  },
  "dependencies": {
    "sharp": "^0.32.6"
  },
  "keywords": [
    "wechat",
    "red-envelope",
    "cover",
    "image",
    "resize",
    "crop"
  ],
  "author": "",
  "license": "MIT"
}

#!/usr/bin/env node

/**
 * 微信红包封面挂件背景去除增强工具
 * 
 * 特点：
 * - 智能背景检测（支持白色、灰色、纯色背景）
 * - 边缘羽化和抗锯齿处理
 * - 保留主体细节，去除背景杂质
 * - 针对AI生成图片优化
 * 
 * 使用方法:
 *   node remove_bg_enhanced.js <输入图片> [输出图片] [选项]
 * 
 * 选项:
 *   --mode <white|gray|auto>  背景检测模式 (默认: auto)
 *   --tolerance <0-100>       背景容差 (默认: 30)
 *   --feather <0-20>          边缘羽化像素 (默认: 3)
 *   --smooth <0-10>           平滑度 (默认: 2)
 *   --min-area <pixels>       最小保留区域 (默认: 100)
 * 
 * 示例:
 *   node remove_bg_enhanced.js input.png output.png --mode white --tolerance 40
 *   node remove_bg_enhanced.js input.png --mode auto --tolerance 35
 */

const sharp = require('sharp');
const fs = require('fs');
const path = require('path');

function parseArgs(argv) {
  const args = {
    input: null,
    output: null,
    mode: 'auto',
    tolerance: 30,
    feather: 3,
    smooth: 2,
    minArea: 100
  };

  for (let i = 0; i < argv.length; i++) {
    const arg = argv[i];
    
    if (arg === '--mode') {
      args.mode = argv[++i];
    } else if (arg === '--tolerance') {
      args.tolerance = parseInt(argv[++i], 10);
    } else if (arg === '--feather') {
      args.feather = parseInt(argv[++i], 10);
    } else if (arg === '--smooth') {
      args.smooth = parseInt(argv[++i], 10);
    } else if (arg === '--min-area') {
      args.minArea = parseInt(argv[++i], 10);
    } else if (!arg.startsWith('--') && !args.input) {
      args.input = arg;
    } else if (!arg.startsWith('--') && !args.output) {
      args.output = arg;
    }
  }

  if (!args.output) {
    const ext = path.extname(args.input);
    const base = args.input.slice(0, -ext.length);
    args.output = `${base}_transparent${ext}`;
  }

  return args;
}

function showHelp() {
  console.log(`
微信红包封面挂件背景去除增强工具

使用方法:
  node remove_bg_enhanced.js <输入图片> [输出图片] [选项]

选项:
  --mode <white|gray|auto>  背景检测模式 (默认: auto)
                            white: 针对白色背景优化
                            gray:  针对灰色背景优化
                            auto:  自动检测
  --tolerance <0-100>       背景容差，越大越激进 (默认: 30)
  --feather <0-20>          边缘羽化像素 (默认: 3)
  --smooth <0-10>           边缘平滑度 (默认: 2)
  --min-area <pixels>       最小保留区域像素数 (默认: 100)

示例:
  # 处理白色背景图片
  node remove_bg_enhanced.js input.png output.png --mode white --tolerance 40
  
  # 自动检测背景
  node remove_bg_enhanced.js input.png --mode auto --tolerance 35

  # 高容差处理（适合复杂背景）
  node remove_bg_enhanced.js input.png --tolerance 50 --feather 5
`);
}

// 计算像素亮度
function getLuminance(r, g, b) {
  return 0.299 * r + 0.587 * g + 0.114 * b;
}

// 计算颜色距离
function colorDistance(r1, g1, b1, r2, g2, b2) {
  const dr = r1 - r2;
  const dg = g1 - g2;
  const db = b1 - b2;
  return Math.sqrt(dr * dr + dg * dg + db * db);
}

// 检测背景颜色
async function detectBackground(imageData, width, height, mode) {
  const samples = [];
  const borderWidth = Math.max(5, Math.floor(Math.min(width, height) * 0.05));
  
  // 从四边采样
  for (let y = 0; y < height; y += 5) {
    for (let x = 0; x < borderWidth; x += 2) {
      const idx = (y * width + x) * 4;
      if (imageData[idx + 3] > 200) {
        samples.push({
          r: imageData[idx],
          g: imageData[idx + 1],
          b: imageData[idx + 2],
          lum: getLuminance(imageData[idx], imageData[idx + 1], imageData[idx + 2])
        });
      }
    }
    for (let x = width - borderWidth; x < width; x += 2) {
      const idx = (y * width + x) * 4;
      if (imageData[idx + 3] > 200) {
        samples.push({
          r: imageData[idx],
          g: imageData[idx + 1],
          b: imageData[idx + 2],
          lum: getLuminance(imageData[idx], imageData[idx + 1], imageData[idx + 2])
        });
      }
    }
  }
  
  for (let x = borderWidth; x < width - borderWidth; x += 5) {
    for (let y = 0; y < borderWidth; y += 2) {
      const idx = (y * width + x) * 4;
      if (imageData[idx + 3] > 200) {
        samples.push({
          r: imageData[idx],
          g: imageData[idx + 1],
          b: imageData[idx + 2],
          lum: getLuminance(imageData[idx], imageData[idx + 1], imageData[idx + 2])
        });
      }
    }
    for (let y = height - borderWidth; y < height; y += 2) {
      const idx = (y * width + x) * 4;
      if (imageData[idx + 3] > 200) {
        samples.push({
          r: imageData[idx],
          g: imageData[idx + 1],
          b: imageData[idx + 2],
          lum: getLuminance(imageData[idx], imageData[idx + 1], imageData[idx + 2])
        });
      }
    }
  }

  if (samples.length < 20) return null;

  // 分析样本统计
  let rSum = 0, gSum = 0, bSum = 0, lumSum = 0;
  for (const s of samples) {
    rSum += s.r; gSum += s.g; bSum += s.b; lumSum += s.lum;
  }
  const rMean = rSum / samples.length;
  const gMean = gSum / samples.length;
  const bMean = bSum / samples.length;
  const lumMean = lumSum / samples.length;

  // 计算颜色方差
  let colorVariance = 0;
  for (const s of samples) {
    colorVariance += colorDistance(s.r, s.g, s.b, rMean, gMean, bMean);
  }
  colorVariance /= samples.length;

  // 判断背景类型
  let bgType = 'mixed';
  if (colorVariance < 30) {
    if (lumMean > 200) bgType = 'white';
    else if (lumMean > 100 && lumMean < 180) bgType = 'gray';
    else bgType = 'dark';
  }

  // 如果用户指定了模式，优先使用用户指定
  if (mode !== 'auto') bgType = mode;

  return {
    r: Math.round(rMean),
    g: Math.round(gMean),
    b: Math.round(bMean),
    luminance: lumMean,
    type: bgType,
    variance: colorVariance
  };
}

// 创建透明度蒙版
function createAlphaMask(imageData, width, height, bgInfo, tolerance) {
  const mask = new Uint8Array(width * height);
  const tolVal = tolerance * 2.55; // 转换为0-255范围
  
  for (let y = 0; y < height; y++) {
    for (let x = 0; x < width; x++) {
      const idx = (y * width + x) * 4;
      const r = imageData[idx];
      const g = imageData[idx + 1];
      const b = imageData[idx + 2];
      
      let isBackground = false;
      let alpha = 255;
      
      if (bgInfo.type === 'white' || bgInfo.type === 'gray') {
        // 基于亮度的检测
        const lum = getLuminance(r, g, b);
        const bgLum = bgInfo.luminance;
        const lumDiff = Math.abs(lum - bgLum);
        
        // 同时考虑颜色距离
        const colorDist = colorDistance(r, g, b, bgInfo.r, bgInfo.g, bgInfo.b);
        
        // 综合判断
        if (lumDiff < tolerance && colorDist < tolVal * 1.5) {
          isBackground = true;
          alpha = 0;
        } else if (lumDiff < tolerance * 1.5 || colorDist < tolVal * 2) {
          // 过渡区域
          const factor = Math.min(lumDiff / (tolerance * 1.5), colorDist / (tolVal * 2));
          alpha = Math.round(255 * Math.max(0, factor - 0.3) / 0.7);
        }
      } else {
        // 通用颜色距离检测
        const dist = colorDistance(r, g, b, bgInfo.r, bgInfo.g, bgInfo.b);
        if (dist < tolVal) {
          isBackground = true;
          alpha = 0;
        } else if (dist < tolVal * 1.8) {
          alpha = Math.round(255 * (dist - tolVal) / (tolVal * 0.8));
        }
      }
      
      mask[y * width + x] = alpha;
    }
  }
  
  return mask;
}

// 应用羽化
function applyFeather(mask, width, height, feather) {
  if (feather <= 0) return mask;
  
  const result = new Uint8Array(mask);
  const temp = new Uint8Array(width * height);
  
  // 多次迭代实现羽化效果
  for (let iter = 0; iter < feather; iter++) {
    for (let y = 1; y < height - 1; y++) {
      for (let x = 1; x < width - 1; x++) {
        const idx = y * width + x;
        
        // 3x3平均
        let sum = 0;
        for (let dy = -1; dy <= 1; dy++) {
          for (let dx = -1; dx <= 1; dx++) {
            sum += mask[(y + dy) * width + (x + dx)];
          }
        }
        temp[idx] = Math.round(sum / 9);
      }
    }
    
    // 复制回mask
    for (let i = 0; i < width * height; i++) {
      mask[i] = temp[i];
    }
  }
  
  return mask;
}

// 去除小噪点
function removeNoise(mask, width, height, minArea) {
  const visited = new Uint8Array(width * height);
  const newMask = new Uint8Array(mask);
  
  function floodFill(startX, startY) {
    const stack = [[startX, startY]];
    const pixels = [];
    visited[startY * width + startX] = 1;
    
    while (stack.length > 0) {
      const [x, y] = stack.pop();
      pixels.push([x, y]);
      
      const neighbors = [[x-1,y], [x+1,y], [x,y-1], [x,y+1]];
      for (const [nx, ny] of neighbors) {
        if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
          const idx = ny * width + nx;
          if (!visited[idx] && mask[idx] > 128) {
            visited[idx] = 1;
            stack.push([nx, ny]);
          }
        }
      }
    }
    
    return pixels;
  }
  
  for (let y = 0; y < height; y++) {
    for (let x = 0; x < width; x++) {
      const idx = y * width + x;
      if (!visited[idx] && mask[idx] > 128) {
        const pixels = floodFill(x, y);
        if (pixels.length < minArea) {
          // 太小的区域设为透明
          for (const [px, py] of pixels) {
            newMask[py * width + px] = 0;
          }
        }
      }
    }
  }
  
  return newMask;
}

async function processImage(inputPath, outputPath, options) {
  console.log(`\n🎨 开始处理: ${path.basename(inputPath)}`);
  console.log(`   模式: ${options.mode}, 容差: ${options.tolerance}, 羽化: ${options.feather}`);
  
  // 读取图片
  const { data, info } = await sharp(inputPath)
    .ensureAlpha()
    .raw()
    .toBuffer({ resolveWithObject: true });
  
  const { width, height } = info;
  console.log(`   尺寸: ${width}×${height}px`);
  
  // 检测背景
  const bgInfo = await detectBackground(data, width, height, options.mode);
  if (!bgInfo) {
    console.log('   ⚠️ 无法检测背景，跳过处理');
    await sharp(inputPath).png().toFile(outputPath);
    return;
  }
  
  console.log(`   检测到背景: ${bgInfo.type} (RGB: ${bgInfo.r},${bgInfo.g},${bgInfo.b})`);
  
  // 创建透明度蒙版
  let mask = createAlphaMask(data, width, height, bgInfo, options.tolerance);
  
  // 去除噪点
  if (options.minArea > 0) {
    mask = removeNoise(mask, width, height, options.minArea);
  }
  
  // 应用羽化
  if (options.feather > 0) {
    mask = applyFeather(mask, width, height, options.feather);
  }
  
  // 应用蒙版到原图
  const outputData = Buffer.from(data);
  for (let i = 0; i < width * height; i++) {
    outputData[i * 4 + 3] = mask[i];
  }
  
  // 保存结果
  await sharp(outputData, {
    raw: { width, height, channels: 4 }
  })
  .png({ compressionLevel: 9 })
  .toFile(outputPath);
  
  const stats = fs.statSync(outputPath);
  console.log(`   ✅ 已保存: ${outputPath}`);
  console.log(`   大小: ${(stats.size / 1024).toFixed(2)}KB`);
}

async function main() {
  const args = process.argv.slice(2);
  
  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
    showHelp();
    process.exit(0);
  }
  
  try {
    require.resolve('sharp');
  } catch (e) {
    console.error('❌ 错误: 缺少依赖 "sharp"');
    console.error('   请先安装: npm install sharp');
    process.exit(1);
  }
  
  const options = parseArgs(args);
  
  if (!fs.existsSync(options.input)) {
    console.error(`❌ 错误: 找不到文件 "${options.input}"`);
    process.exit(1);
  }
  
  await processImage(options.input, options.output, options);
  console.log('\n🎉 处理完成!');
}

main().catch(err => {
  console.error(`\n❌ 错误: ${err.message}`);
  process.exit(1);
});

#!/usr/bin/env node

/**
 * 微信红包封面图片尺寸裁剪工具
 * 
 * 支持微信红包封面开放平台的所有尺寸规范：
 * - 封面图: 957×1278px (3:4) ≤500KB
 * - 封面挂件: 1053×1746px (3:5) ≤300KB
 * - 气泡挂件: 480×384px (5:4) ≤300KB
 * - 封面故事: 750×1250px (3:5) ≤300KB
 * 
 * 自动压缩功能：如果文件超出限制，会自动降低质量直到符合要求
 * 
 * 注意：本脚本仅负责尺寸裁剪和压缩，背景去除请使用 remove_bg_enhanced.js
 * 
 * 使用方法:
 *   node resize_cover.js <输入图片路径> <类型> [输出路径]
 *   node resize_cover.js <输入图片路径> all [输出目录]
 * 
 * 示例:
 *   node resize_cover.js myimage.png cover
 *   node resize_cover.js myimage.png all ./output
 */

let sharp;
const path = require('path');
const fs = require('fs');

// 微信红包封面尺寸规范
const DIMENSIONS = {
  cover: {
    name: '封面图',
    width: 957,
    height: 1278,
    ratio: '3:4',
    sizeLimit: 500, // KB
    safeZone: {
      top: 0.25,
      middle: 0.50,
      bottom: 0.15
    }
  },
  hang: {
    name: '封面挂件',
    width: 1053,
    height: 1746,
    ratio: '3:5',
    sizeLimit: 300, // KB
    transparent: true,
    // 微信红包封面挂件：仅顶部可编辑区域允许出现内容，其余区域应完全透明
    // 这里按"顶部 324px 可编辑"约束（来自平台编辑器示意图/规范）
    editableRegions: [{ top: 0, height: 324 }],
    safeZone: {
      top: 324 / 1746,
      bottom: 1 - 324 / 1746,
    }
  },
  bubble: {
    name: '气泡挂件',
    width: 480,
    height: 384,
    ratio: '5:4',
    sizeLimit: 300, // KB
    transparent: true,
    // 气泡挂件（480×384）：可编辑区域为上下两段，中间为不可编辑区域
    // 按平台编辑器示意图：顶部96px可编辑，中间216px不可编辑（必须透明），底部72px可编辑
    editableRegions: [
      { top: 0, height: 96 },
      { top: 384 - 72, height: 72 },
    ],
  },
  story: {
    name: '封面故事',
    width: 750,
    height: 1250,
    ratio: '3:5',
    sizeLimit: 300, // KB
    safeZone: {
      top: 0.10,
      middle: 0.80,
      bottom: 0.10
    }
  }
};

function showHelp() {
  console.log(`
微信红包封面图片尺寸裁剪工具 (带自动压缩)

使用方法:
  node resize_cover.js <输入图片路径> <类型> [输出路径]
  node resize_cover.js <输入图片路径> all [输出目录]

参数说明:
  输入图片路径 - 原始图片路径
  类型         - cover|hang|bubble|story|all
  输出路径     - 可选，默认为输入文件名_类型.png

尺寸与大小限制:
  cover  - 封面图: 957×1278px, ≤500KB
  hang   - 封面挂件: 1053×1746px, ≤300KB, PNG透明
  bubble - 气泡挂件: 480×384px, ≤300KB, PNG透明
  story  - 封面故事: 750×1250px, ≤300KB

注意：
  本脚本仅处理尺寸裁剪和压缩，不处理背景去除。
  如需去除背景，请使用 remove_bg_enhanced.js 脚本。

特性:
  ✓ 自动居中裁剪，保持目标比例
  ✓ 智能压缩，自动调整质量满足大小限制
  ✓ 挂件类自动强制安全区域透明
  ✓ 显示安全区域提示

示例:
  node resize_cover.js myimage.png cover
  node resize_cover.js myimage.png all ./output
  node resize_cover.js cover.png hang pendant.png
  node resize_cover.js bubble.png bubble bubble_final.png
`);
}

function parseArgs(argv) {
  const positionals = [];
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (!a.startsWith('--')) {
      positionals.push(a);
    }
  }
  return positionals;
}

async function getImageInfo(inputPath) {
  try {
    const metadata = await sharp(inputPath).metadata();
    return {
      width: metadata.width,
      height: metadata.height,
      format: metadata.format,
      size: fs.statSync(inputPath).size
    };
  } catch (error) {
    throw new Error(`无法读取图片: ${error.message}`);
  }
}

function calculateCropDimensions(imgWidth, imgHeight, targetWidth, targetHeight) {
  const targetRatio = targetWidth / targetHeight;
  const currentRatio = imgWidth / imgHeight;
  
  let cropWidth, cropHeight, left, top;
  
  if (currentRatio > targetRatio) {
    cropHeight = imgHeight;
    cropWidth = Math.round(imgHeight * targetRatio);
    left = Math.round((imgWidth - cropWidth) / 2);
    top = 0;
  } else {
    cropWidth = imgWidth;
    cropHeight = Math.round(imgWidth / targetRatio);
    left = 0;
    top = Math.round((imgHeight - cropHeight) / 2);
  }
  
  return { cropWidth, cropHeight, left, top };
}

// 智能压缩函数：尝试不同质量设置直到满足大小限制
async function compressToLimit(buffer, type, sizeLimitKB, isTransparent) {
  const sizeLimitBytes = sizeLimitKB * 1024;
  
  // 如果已经符合要求，直接返回
  if (buffer.length <= sizeLimitBytes) {
    return { buffer, quality: null, format: 'original' };
  }
  
  console.log(`   原始大小: ${(buffer.length / 1024).toFixed(2)}KB，需要压缩...`);
  
  // 对于非透明图片，使用JPEG压缩（压缩率更好）
  if (!isTransparent && type !== 'hang' && type !== 'bubble') {
    // 尝试JPEG不同质量
    const qualities = [90, 85, 80, 75, 70, 65, 60];
    
    for (const quality of qualities) {
      const jpegBuffer = await sharp(buffer)
        .jpeg({ quality, progressive: true, mozjpeg: true })
        .toBuffer();
      
      if (jpegBuffer.length <= sizeLimitBytes) {
        return { buffer: jpegBuffer, quality, format: 'jpeg' };
      }
    }
    
    // 如果JPEG还是太大，尝试更低质量
    const lowQualityBuffer = await sharp(buffer)
      .jpeg({ quality: 55, progressive: true, mozjpeg: true })
      .toBuffer();
    
    if (lowQualityBuffer.length <= sizeLimitBytes) {
      return { buffer: lowQualityBuffer, quality: 55, format: 'jpeg' };
    }
  }
  
  // 对于透明图片（挂件），使用PNG优化
  if (isTransparent) {
    // 尝试使用8-bit调色板PNG
    const paletteBuffer = await sharp(buffer)
      .png({ 
        compressionLevel: 9,
        adaptiveFiltering: true,
        palette: true,
        quality: 80
      })
      .toBuffer();
    
    if (paletteBuffer.length <= sizeLimitBytes) {
      return { buffer: paletteBuffer, quality: 80, format: 'png-palette' };
    }
    
    // 尝试更低质量的调色板
    const lowPaletteBuffer = await sharp(buffer)
      .png({ 
        compressionLevel: 9,
        adaptiveFiltering: true,
        palette: true,
        quality: 60,
        effort: 10
      })
      .toBuffer();
    
    if (lowPaletteBuffer.length <= sizeLimitBytes) {
      return { buffer: lowPaletteBuffer, quality: 60, format: 'png-palette' };
    }
    
    // 尝试颜色数量限制
    const colorsBuffer = await sharp(buffer)
      .png({ 
        compressionLevel: 9,
        palette: true,
        colours: 128,
        effort: 10
      })
      .toBuffer();
    
    if (colorsBuffer.length <= sizeLimitBytes) {
      return { buffer: colorsBuffer, quality: null, format: 'png-128colors' };
    }
  }
  
  // 通用降级策略：降低分辨率
  const img = sharp(buffer);
  const metadata = await img.metadata();
  const scale = Math.sqrt(sizeLimitBytes / buffer.length) * 0.95; // 留一些余量
  
  const newWidth = Math.floor(metadata.width * scale);
  const newHeight = Math.floor(metadata.height * scale);
  
  const resizedBuffer = await img
    .resize(newWidth, newHeight, { 
      fit: 'inside',
      withoutEnlargement: false
    })
    .png({ compressionLevel: 9 })
    .toBuffer();
  
  return { 
    buffer: resizedBuffer, 
    quality: null, 
    format: `resized-${newWidth}x${newHeight}` 
  };
}

async function processImage(inputPath, type, outputPath) {
  const config = DIMENSIONS[type];
  const imgInfo = await getImageInfo(inputPath);
  
  console.log(`\n📸 ${config.name}`);
  console.log(`   原始: ${imgInfo.width}×${imgInfo.height}px, ${(imgInfo.size / 1024).toFixed(2)}KB`);
  console.log(`   目标: ${config.width}×${config.height}px, ≤${config.sizeLimit}KB`);
  
  // 计算裁剪参数
  const { cropWidth, cropHeight, left, top } = calculateCropDimensions(
    imgInfo.width,
    imgInfo.height,
    config.width,
    config.height
  );
  
  // 裁剪和调整尺寸
  let processedBuffer = await sharp(inputPath)
    .extract({ left, top, width: cropWidth, height: cropHeight })
    .resize(config.width, config.height, { fit: 'fill' })
    .toBuffer();
  
  console.log(`   裁剪: ${cropWidth}×${cropHeight}px → ${config.width}×${config.height}px`);
  
  // 挂件类需要透明背景：统一强制输出PNG+alpha，避免输入是JPG时丢失透明信息
  if (config.transparent) {
    processedBuffer = await sharp(processedBuffer).ensureAlpha().png().toBuffer();
  }

  // 强制限制可编辑区域：仅允许指定区域内出现任何不透明像素。
  // 这样即便生成图"画满了整张"，最终交付也会自动裁掉不可编辑区域的内容。
  if (config.transparent && Array.isArray(config.editableRegions) && config.editableRegions.length > 0) {
    const composites = [];

    for (const region of config.editableRegions) {
      const regionTop = Math.max(0, Math.min(region.top, config.height - 1));
      const regionHeight = Math.max(0, Math.min(region.height, config.height - regionTop));
      if (!regionHeight) continue;

      const extracted = await sharp(processedBuffer)
        .extract({ left: 0, top: regionTop, width: config.width, height: regionHeight })
        .toBuffer();

      composites.push({ input: extracted, left: 0, top: regionTop });
    }

    processedBuffer = await sharp({
      create: {
        width: config.width,
        height: config.height,
        channels: 4,
        background: { r: 0, g: 0, b: 0, alpha: 0 },
      },
    })
      .composite(composites)
      .png()
      .toBuffer();
  }
  
  // 压缩到符合大小限制
  const { buffer: finalBuffer, quality, format } = await compressToLimit(
    processedBuffer,
    type,
    config.sizeLimit,
    config.transparent
  );
  
  // 确定输出格式
  let finalOutputPath = outputPath;
  if (format === 'jpeg' && !outputPath.toLowerCase().endsWith('.jpg')) {
    finalOutputPath = outputPath.replace(/\.png$/i, '.jpg');
  }
  
  // 确保输出目录存在
  const outputDir = path.dirname(finalOutputPath);
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }
  
  // 保存文件
  fs.writeFileSync(finalOutputPath, finalBuffer);
  
  const finalSizeKB = finalBuffer.length / 1024;
  const status = finalSizeKB <= config.sizeLimit ? '✅' : '⚠️';
  
  console.log(`   ${status} 已保存: ${finalOutputPath}`);
  console.log(`      大小: ${finalSizeKB.toFixed(2)}KB / ${config.sizeLimit}KB`);
  
  if (quality) {
    console.log(`      压缩: ${format}, 质量${quality}%`);
  } else if (format !== 'original') {
    console.log(`      压缩: ${format}`);
  }
  
  if (finalSizeKB > config.sizeLimit) {
    console.warn(`      ⚠️ 警告: 仍超出限制，建议手动检查或优化原图`);
  }
  
  return finalOutputPath;
}

async function batchResize(inputPath, outputDir) {
  console.log(`\n🚀 批量处理 - 生成所有尺寸\n`);
  
  if (!outputDir) {
    outputDir = path.dirname(inputPath) || '.';
  }
  
  const baseName = path.basename(inputPath, path.extname(inputPath));
  const results = [];
  
  for (const [type, config] of Object.entries(DIMENSIONS)) {
    const outputPath = path.join(outputDir, `${baseName}_${type}.png`);
    try {
      await processImage(inputPath, type, outputPath);
      results.push({ type, status: 'success', path: outputPath });
    } catch (error) {
      results.push({ type, status: 'error', error: error.message });
      console.error(`   ❌ 失败: ${error.message}`);
    }
  }
  
  // 打印汇总
  console.log(`\n📊 处理完成`);
  console.log('='.repeat(60));
  results.forEach(result => {
    const config = DIMENSIONS[result.type];
    if (result.status === 'success') {
      const stats = fs.statSync(result.path);
      const sizeKB = (stats.size / 1024).toFixed(2);
      const statusIcon = stats.size <= config.sizeLimit * 1024 ? '✅' : '⚠️';
      console.log(`${statusIcon} ${config.name}: ${sizeKB}KB / ${config.sizeLimit}KB`);
      console.log(`   ${result.path}`);
    } else {
      console.log(`❌ ${config.name}: ${result.error}`);
    }
  });
  console.log('='.repeat(60));
  
  return results;
}

async function main() {
  const args = parseArgs(process.argv.slice(2));
  
  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
    showHelp();
    process.exit(0);
  }
  
  // 检查sharp是否安装
  try {
    require.resolve('sharp');
    sharp = require('sharp');
  } catch (e) {
    console.error('❌ 错误: 缺少依赖 "sharp"');
    console.error('   请先安装: npm install sharp');
    process.exit(1);
  }
  
  const inputPath = args[0];
  
  if (!fs.existsSync(inputPath)) {
    console.error(`❌ 错误: 找不到文件 "${inputPath}"`);
    process.exit(1);
  }
  
  // 批量处理
  if (args[1] === 'all' || args[1] === '--all') {
    await batchResize(inputPath, args[2]);
    return;
  }
  
  if (args.length < 2) {
    console.error('❌ 错误: 缺少类型参数');
    console.error('   使用: node resize_cover.js <图片> <类型> [输出]');
    process.exit(1);
  }
  
  const type = args[1];
  
  if (!DIMENSIONS[type]) {
    console.error(`❌ 错误: 不支持的类型 "${type}"`);
    console.error('   支持: cover, hang, bubble, story');
    process.exit(1);
  }
  
  let outputPath = args[2];
  if (!outputPath) {
    const dir = path.dirname(inputPath) || '.';
    const baseName = path.basename(inputPath, path.extname(inputPath));
    outputPath = path.join(dir, `${baseName}_${type}.png`);
  }
  
  await processImage(inputPath, type, outputPath);
  
  // 显示安全区域提示
  const config = DIMENSIONS[type];
  console.log(`\n💡 安全区域提示:`);
  if (Array.isArray(config.editableRegions) && config.editableRegions.length > 0) {
    if (type === 'hang') {
      console.log(`   - 仅顶部${config.editableRegions[0].height}px可编辑/可出现元素`);
      console.log(`   - 其余区域必须完全透明留空`);
      return;
    }
    if (type === 'bubble') {
      const top = config.editableRegions[0];
      const bottom = config.editableRegions[1];
      const middle = config.height - top.height - bottom.height;
      console.log(`   - 顶部${top.height}px可编辑/可出现元素`);
      console.log(`   - 中间${middle}px必须完全透明留空（不可编辑区域）`);
      console.log(`   - 底部${bottom.height}px可编辑/可出现元素`);
      return;
    }
  }
  if (config.safeZone.top && config.safeZone.middle && config.safeZone.bottom) {
    console.log(`   - 上方${(config.safeZone.top * 100).toFixed(0)}%: 保持简洁，确保文字可读`);
    console.log(`   - 中部${(config.safeZone.middle * 100).toFixed(0)}%: 主要视觉元素区域`);
    console.log(`   - 底部${(config.safeZone.bottom * 100).toFixed(0)}%: 避免放置关键元素`);
  } else if (config.safeZone.top && config.safeZone.bottom) {
    console.log(`   - 上方${(config.safeZone.top * 100).toFixed(0)}%: 设计元素区域`);
    console.log(`   - 下方${(config.safeZone.bottom * 100).toFixed(0)}%: 必须留白/透明`);
  }
}

main().catch(error => {
  console.error(`\n❌ 处理失败: ${error.message}`);
  process.exit(1);
});