/**
|
* 统一图片处理器
|
* 集成缩略图生成、图片压缩、尺寸调整等功能
|
* 使用 Jimp 和 Electron nativeImage 多引擎支持
|
*/
|
|
const fs = require('fs').promises;
|
const path = require('path');
|
const { nativeImage } = require('electron');
|
|
class ImageProcessor {
|
constructor() {
|
this.engines = [];
|
this.initEngines();
|
}
|
|
/**
|
* 初始化所有可用引擎
|
*/
|
initEngines() {
|
// 引擎优先级：Jimp > Electron Native
|
|
// 1. Jimp (纯 JS，跨平台兼容性最好)
|
this.engines.push({
|
name: 'jimp',
|
check: () => {
|
try {
|
require('jimp');
|
return true;
|
} catch {
|
return false;
|
}
|
},
|
process: this.processWithJimp.bind(this)
|
});
|
|
// 2. Electron nativeImage (始终可用的备用方案)
|
this.engines.push({
|
name: 'electron',
|
check: () => true,
|
process: this.processWithElectron.bind(this)
|
});
|
|
console.log('[ImageProcessor] 初始化完成，可用引擎:',
|
this.engines.filter(e => e.check()).map(e => e.name).join(', '));
|
}
|
|
/**
|
* 生成缩略图（自动选择引擎）
|
* @param {string} inputPath - 输入图片路径
|
* @param {string} outputPath - 输出图片路径
|
* @param {Object} options - 选项
|
* @param {number} options.width - 宽度，默认200
|
* @param {number} options.height - 高度，默认200
|
* @param {number} options.quality - 质量，默认80
|
* @param {string} options.mode - 缩放模式，默认'cover'
|
* @returns {Promise<Object>} 处理结果
|
*/
|
async generateThumbnail(inputPath, outputPath, options = {}) {
|
const {
|
width = 200,
|
height = 200,
|
quality = 80,
|
mode = 'cover'
|
} = options;
|
|
// 确保输出目录存在
|
const outputDir = path.dirname(outputPath);
|
await fs.mkdir(outputDir, { recursive: true });
|
|
// 尝试每个引擎
|
for (const engine of this.engines) {
|
if (!engine.check()) {
|
console.log(`[ImageProcessor] ${engine.name} 不可用，跳过`);
|
continue;
|
}
|
|
try {
|
console.log(`[ImageProcessor] 使用 ${engine.name} 引擎`);
|
const result = await engine.process(inputPath, outputPath, { width, height, quality, mode });
|
console.log(`[ImageProcessor] ${engine.name} 成功处理图片`);
|
return {
|
...result,
|
engine: engine.name,
|
success: true
|
};
|
} catch (error) {
|
console.error(`[ImageProcessor] ${engine.name} 失败:`, error.message);
|
// 继续尝试下一个引擎
|
}
|
}
|
|
throw new Error('所有图片处理引擎都失败了');
|
}
|
|
/**
|
* Jimp 引擎处理
|
*/
|
async processWithJimp(inputPath, outputPath, options) {
|
const Jimp = require('jimp');
|
|
const image = await Jimp.read(inputPath);
|
const { width, height, quality, mode = 'cover' } = options;
|
|
// 根据模式选择不同的缩放方式
|
if (mode === 'cover') {
|
// 覆盖模式：保持比例，裁剪多余部分
|
await image
|
.cover(width, height, Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE)
|
.quality(quality)
|
.writeAsync(outputPath);
|
} else if (mode === 'contain') {
|
// 包含模式：保持比例，完整显示
|
await image
|
.contain(width, height, Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE)
|
.quality(quality)
|
.writeAsync(outputPath);
|
} else if (mode === 'resize') {
|
// 拉伸模式：不保持比例，直接缩放
|
await image
|
.resize(width, height)
|
.quality(quality)
|
.writeAsync(outputPath);
|
} else if (mode === 'scaleToFit') {
|
// 适应模式：保持比例，缩放到适合尺寸
|
await image
|
.scaleToFit(width, height)
|
.quality(quality)
|
.writeAsync(outputPath);
|
} else {
|
// 默认使用 cover 模式
|
await image
|
.cover(width, height, Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE)
|
.quality(quality)
|
.writeAsync(outputPath);
|
}
|
|
const stats = await fs.stat(outputPath);
|
return {
|
path: outputPath,
|
size: stats.size,
|
mode: mode
|
};
|
}
|
|
/**
|
* Electron 原生引擎处理
|
*/
|
async processWithElectron(inputPath, outputPath, options) {
|
// 读取图片
|
const imageBuffer = await fs.readFile(inputPath);
|
const image = nativeImage.createFromBuffer(imageBuffer);
|
|
// 获取原始尺寸
|
const { width: origWidth, height: origHeight } = image.getSize();
|
const { width, height, quality, mode = 'cover' } = options;
|
|
let resized;
|
|
if (mode === 'cover') {
|
// 覆盖模式：保持比例，裁剪多余部分
|
const scale = Math.max(width / origWidth, height / origHeight);
|
const scaledWidth = Math.round(origWidth * scale);
|
const scaledHeight = Math.round(origHeight * scale);
|
|
resized = image.resize({
|
width: scaledWidth,
|
height: scaledHeight,
|
quality: 'best'
|
});
|
|
// 从中心裁剪到精确尺寸
|
if (scaledWidth !== width || scaledHeight !== height) {
|
const x = Math.round((scaledWidth - width) / 2);
|
const y = Math.round((scaledHeight - height) / 2);
|
|
resized = resized.crop({
|
x: Math.max(0, x),
|
y: Math.max(0, y),
|
width: width,
|
height: height
|
});
|
}
|
} else if (mode === 'contain') {
|
// 包含模式：保持比例，完整显示（可能有黑边）
|
const scale = Math.min(width / origWidth, height / origHeight);
|
const scaledWidth = Math.round(origWidth * scale);
|
const scaledHeight = Math.round(origHeight * scale);
|
|
resized = image.resize({
|
width: scaledWidth,
|
height: scaledHeight,
|
quality: 'best'
|
});
|
} else if (mode === 'resize') {
|
// 拉伸模式：不保持比例，直接缩放
|
resized = image.resize({
|
width: width,
|
height: height,
|
quality: 'best'
|
});
|
} else if (mode === 'scaleToFit') {
|
// 适应模式：保持比例，缩放到不超过目标尺寸
|
const scale = Math.min(width / origWidth, height / origHeight, 1);
|
const scaledWidth = Math.round(origWidth * scale);
|
const scaledHeight = Math.round(origHeight * scale);
|
|
resized = image.resize({
|
width: scaledWidth,
|
height: scaledHeight,
|
quality: 'best'
|
});
|
} else {
|
// 默认使用 cover 模式
|
const scale = Math.max(width / origWidth, height / origHeight);
|
const scaledWidth = Math.round(origWidth * scale);
|
const scaledHeight = Math.round(origHeight * scale);
|
|
resized = image.resize({
|
width: scaledWidth,
|
height: scaledHeight,
|
quality: 'best'
|
});
|
}
|
|
// 转换为 JPEG
|
const jpegBuffer = resized.toJPEG(quality);
|
await fs.writeFile(outputPath, jpegBuffer);
|
|
return {
|
path: outputPath,
|
size: jpegBuffer.length,
|
mode: mode
|
};
|
}
|
|
/**
|
* 批量生成缩略图
|
*/
|
async batchGenerate(images, options = {}) {
|
const results = [];
|
const { concurrency = 3 } = options;
|
|
// 分批处理
|
for (let i = 0; i < images.length; i += concurrency) {
|
const batch = images.slice(i, i + concurrency);
|
const batchPromises = batch.map(({ input, output, ...imgOptions }) =>
|
this.generate(input, output, { ...options, ...imgOptions })
|
.then(result => ({ ...result, input, output }))
|
.catch(error => ({
|
success: false,
|
error: error.message,
|
input,
|
output
|
}))
|
);
|
|
const batchResults = await Promise.all(batchPromises);
|
results.push(...batchResults);
|
}
|
|
return results;
|
}
|
|
/**
|
* 获取可用引擎信息
|
*/
|
getAvailableEngines() {
|
return this.engines
|
.filter(e => e.check())
|
.map(e => e.name);
|
}
|
|
/**
|
* 检查特定引擎是否可用
|
*/
|
isEngineAvailable(engineName) {
|
const engine = this.engines.find(e => e.name === engineName);
|
return engine ? engine.check() : false;
|
}
|
|
/**
|
* 便捷方法：生成缩略图（向后兼容）
|
* @deprecated 使用 generateThumbnail 代替
|
*/
|
async generate(inputPath, outputPath, options = {}) {
|
console.warn('[ImageProcessor] generate() 方法已废弃，请使用 generateThumbnail()');
|
return this.generateThumbnail(inputPath, outputPath, options);
|
}
|
|
/**
|
* 便捷方法：压缩图片
|
*/
|
async compress(inputPath, outputPath, options = {}) {
|
return this.generateThumbnail(inputPath, outputPath, {
|
...options,
|
mode: 'scaleToFit' // 压缩时保持比例
|
});
|
}
|
|
/**
|
* 便捷方法：调整尺寸
|
*/
|
async resize(inputPath, outputPath, width, height, options = {}) {
|
return this.generateThumbnail(inputPath, outputPath, {
|
width,
|
height,
|
mode: 'resize', // 拉伸模式
|
...options
|
});
|
}
|
|
/**
|
* 获取图片信息
|
*/
|
async getImageInfo(imagePath) {
|
try {
|
// 优先使用 Jimp 获取详细信息
|
if (this.isEngineAvailable('jimp')) {
|
const Jimp = require('jimp');
|
const image = await Jimp.read(imagePath);
|
return {
|
width: image.bitmap.width,
|
height: image.bitmap.height,
|
mime: image._originalMime,
|
hasAlpha: image.hasAlpha()
|
};
|
}
|
|
// 备用：使用 Electron nativeImage
|
const imageBuffer = await fs.readFile(imagePath);
|
const image = nativeImage.createFromBuffer(imageBuffer);
|
const { width, height } = image.getSize();
|
|
return {
|
width,
|
height,
|
mime: 'unknown',
|
hasAlpha: false
|
};
|
} catch (error) {
|
console.error('[ImageProcessor] 获取图片信息失败:', error);
|
throw error;
|
}
|
}
|
}
|
|
// 导出单例
|
module.exports = new ImageProcessor();
|
