Update egg-api.js

egg-api.js

@@ -1,153 +1,314 @@
 const express = require('express');
-const fs = require('fs');
-const path = require('path');
 const cv = require('opencv4nodejs');
 const Jimp = require('jimp');
 const axios = require('axios');
-const sharp = require('sharp');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const ffmpeg = require('fluent-ffmpeg');
 const serveStatic = require('serve-static');
 
 const app = express();
-const port = 7860;
+const PORT = 7860;
 
 // 从文件夹加载所有分类器
-const loadClassifiersFromFolder = async (folderPath) => {
-  const classifiers = [];
-  const files = fs.readdirSync(folderPath);
-  for (const file of files) {
-    const filePath = path.join(folderPath, file);
-    const classifier = new cv.CascadeClassifier(filePath);
-    classifiers.push(classifier);
-  }
-  return classifiers;
-};
-
-// 下载并转换图像到内存中
-const downloadAndConvertImage = async (url) => {
-  try {
-    const response = await axios({
-      method: 'get',
-      url: url,
-      responseType: 'arraybuffer'
-    });
+async function loadClassifiersFromFolder(folderPath) {
+    console.log(`开始从文件夹 ${folderPath} 加载分类器...`);
+    const classifiers = [];
 
-    const imageBuffer = await sharp(response.data)
-      .toFormat('jpeg')
-      .toBuffer();
-
-    console.log('Image downloaded and converted successfully.');
-    return imageBuffer;
-  } catch (error) {
-    console.error('Error downloading or converting image:', error);
-    throw error;
-  }
-};
-
-// 图像处理函数
-const processImage = async (imageBuffer, classifiersFolder, replacementImageBuffer) => {
-  try {
-    const classifiers = await loadClassifiersFromFolder(classifiersFolder);
-  
-    const jimpImage = await Jimp.read(imageBuffer);
-    if (!jimpImage) {
-      throw new Error('Failed to read the image with Jimp. The image file might be corrupted or not supported.');
-    }
-  
-    const img = cv.imdecode(imageBuffer);
-    if (img.empty) {
-      throw new Error('Failed to read the image with OpenCV. The image file might be corrupted or not supported.');
+    const files = fs.readdirSync(folderPath);
+    for (const file of files) {
+        const filePath = path.join(folderPath, file);
+        const classifier = new cv.CascadeClassifier(filePath);
+        classifiers.push(classifier);
+        console.log(`加载分类器: ${file}`);
     }
-  
-    const grayImg = img.bgrToGray();
-    const allFaces = [];
-    classifiers.forEach(classifier => {
-      const faces = classifier.detectMultiScale(grayImg).objects;
-      allFaces.push(...faces);
+
+    console.log('分类器加载完成');
+    return classifiers;
+}
+
+// GIF 转换为视频
+async function gifToVideo(inputGifPath, outputVideoPath) {
+    console.log('开始将GIF转换为视频...');
+    return new Promise((resolve, reject) => {
+        ffmpeg(inputGifPath)
+            .inputFormat('gif')
+            .output(outputVideoPath)
+            .on('start', (commandLine) => {
+                console.log('FFmpeg 命令:', commandLine);
+            })
+            .on('end', () => {
+                console.log('GIF成功转换为视频:', outputVideoPath);
+                resolve();
+            })
+            .on('error', (err) => {
+                console.error('GIF转换为视频时出错:', err);
+                reject(err);
+            })
+            .run();
     });
-  
-    // 如果没有检测到人脸，抛出错误
-    if (allFaces.length === 0) {
-      throw new Error('No faces detected in the image.');
-    }
-  
-    const replacementFace = await Jimp.read(replacementImageBuffer);
-    allFaces.forEach((faceRect, i) => {
-      const resizedReplacementFace = replacementFace.resize(faceRect.width, faceRect.height);
-      const faceRegion = img.getRegion(faceRect);
-  
-      const replacementBuffer = resizedReplacementFace.bitmap.data;
-      const centerX = faceRect.width / 2;
-      const centerY = faceRect.height / 2;
-      const maxRadius = Math.min(centerX, centerY);
-      for (let y = 0; y < faceRect.height; y++) {
-        for (let x = 0; x < faceRect.width; x++) {
-          const distance = Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2);
-          if (distance <= maxRadius) {
-            const idx = (y * faceRect.width + x) << 2;
-            const [r, g, b, a] = replacementBuffer.slice(idx, idx + 4);
-  
-            if (a > 0) {
-              faceRegion.set(y, x, new cv.Vec3(b, g, r));
-            }
-          }
-        }
-      }
+}
+
+// 视频转换为 GIF
+async function videoToGif(inputVideoPath, outputGifPath) {
+    console.log('开始将视频转换为GIF...');
+    return new Promise((resolve, reject) => {
+        ffmpeg(inputVideoPath)
+            .output(outputGifPath)
+            .on('start', (commandLine) => {
+                console.log('FFmpeg 命令:', commandLine);
+            })
+            .on('end', () => {
+                console.log('视频成功转换为GIF:', outputGifPath);
+                resolve();
+            })
+            .on('error', (err) => {
+                console.error('视频转换为GIF时出错:', err);
+                reject(err);
+            })
+            .run();
     });
-    const outputBuffer = cv.imencode('.jpg', img);
-    return outputBuffer;
-  } catch (error) {
-    console.error('Error during image processing:', error);
-    throw error;
-  }
-};
-
-// Express接口
+}
+// 下载并转换图片到内存的辅助函数
+async function downloadAndConvertImage(url) {
+    const response = await axios.get(url, { responseType: 'arraybuffer' });
+    return await Jimp.read(response.data);
+}
+
+// 处理图片的 Express 接口
 app.get('/process-image', async (req, res) => {
-  const { imageUrl, replacementImageUrl } = req.query;
-  
-  if (!imageUrl || !replacementImageUrl) {
-    return res.status(400).send('Both image URL and replacement image URL are required');
-  }
-  
-  const classifiersFolder = './classifiers';
-  let replacementImageBuffer;
-  try {
-    // 下载并转换输入图片和替换图片到内存中
-    const imageBuffer = await downloadAndConvertImage(imageUrl);
-    if (replacementImageUrl === 'replace') {
-      // 使用默认的本地替换图像路径
-      const defaultReplacementImagePath = './replacement_face.png';
-      replacementImageBuffer = await Jimp.read(defaultReplacementImagePath);
-    } else {
-      // 下载并转换替换图片到内存中
-      replacementImageBuffer = await downloadAndConvertImage(replacementImageUrl);
-    }
-  
-    // 处理图片
-    const outputBuffer = await processImage(imageBuffer, classifiersFolder, replacementImageBuffer);
-  
-    // 返回处理后的图片
-    res.set('Content-Type', 'image/jpeg');
-    res.send(outputBuffer);
-  } catch (error) {
-    if (error.message === 'No faces detected in the image.') {
-      res.status(404).send('No faces detected in the image.');
-    } else {
-      console.error('Error processing image:', error);
-      res.status(500).send('Error processing image');
+    try {
+        const { imageUrl, replacementImageUrl } = req.query;
+        const tempDir = os.tmpdir();
+        const tempImagePath = path.join(tempDir, 'temp_image.jpg');
+        const tempImagePaths = path.join(tempDir, 'temp_images.jpg');
+        const outputImagePath = path.join(tempDir, 'output_image.jpg');
+        const classifiersFolder = path.join(__dirname, 'classifiers');
+
+        console.log('接收到图片处理请求:', imageUrl);
+
+        // 下载图片到本地
+        console.log('开始下载图片...');
+        const response = await axios.get(imageUrl, { responseType: 'stream' });
+        const writer = fs.createWriteStream(tempImagePath);
+        response.data.pipe(writer);
+
+        // 等待文件写入完成
+        await new Promise((resolve, reject) => {
+            writer.on('finish', resolve);
+            writer.on('error', reject);
+        });
+
+        let replacementImageBuffer;
+        if (replacementImageUrl === 'replace') {
+            // 使用默认的本地替换图像路径
+            const defaultReplacementImagePath = './replacement_face.png';
+            replacementImageBuffer = await Jimp.read(defaultReplacementImagePath);
+        } else {
+            // 下载并转换替换图片到内存中
+            const response = await axios.get(replacementImageUrl, { responseType: 'stream' });
+            const writer = fs.createWriteStream(tempImagePaths);
+            response.data.pipe(writer);
+
+            // 等待文件写入完成
+            await new Promise((resolve, reject) => {
+                writer.on('finish', resolve);
+                writer.on('error', reject);
+            });
+
+            replacementImageBuffer = await Jimp.read(tempImagePath)
+        }
+        console.log('图片下载完成:', tempImagePath);
+
+        // 从文件夹动态加载分类器
+        const classifiers = await loadClassifiersFromFolder(classifiersFolder);
+
+        // 读取图片
+        console.log('开始读取图片...');
+        const image = await cv.imreadAsync(tempImagePath);
+        const grayImage = image.bgrToGray();
+
+        // 检测人脸
+        console.log('开始检测人脸...');
+        const faces = [];
+        classifiers.forEach(classifier => {
+            const allFaces = classifier.detectMultiScale(grayImage).objects;
+            faces.push(...allFaces);
+        });
+
+
+
+        const replacementFace = replacementImageBuffer;
+
+        if (Array.isArray(faces) && faces.length > 0) {
+            console.log(`检测到 ${faces.length} 张脸`);
+            for (const rect of faces) {
+                const resizedSubstituteImage = await replacementFace.clone().resize(rect.width, rect.height);
+                const substituteRegion = image.getRegion(rect);
+                for (let y = 0; y < rect.height; y++) {
+                    for (let x = 0; x < rect.width; x++) {
+                        const { r, g, b, a } = Jimp.intToRGBA(resizedSubstituteImage.getPixelColor(x, y));
+                        if (a > 0) {
+                            const color = new cv.Vec3(b, g, r);
+                            substituteRegion.set(y, x, color);
+                        }
+                    }
+                }
+            }
+        } else {
+            console.error('未检测到人脸或faces数组为空');
+        }
+
+        // 保存处理后的图片
+        await cv.imwriteAsync(outputImagePath, image);
+        console.log('图片处理完成并保存:', outputImagePath);
+
+        // 发送处理后的图片
+        res.set('Content-Type', 'image/jpeg');
+        res.sendFile(outputImagePath, async (err) => {
+            if (err) {
+                console.error('发送文件时出错:', err);
+                res.status(500).send('内部服务器错误');
+            } else {
+                // 删除临时文件
+                fs.unlinkSync(tempImagePath);
+                fs.unlinkSync(tempImagePaths);
+                fs.unlinkSync(outputImagePath);
+            }
+        });
+    } catch (error) {
+        console.error('处理图片时出错:', error);
+        res.status(500).send('内部服务器错误');
     }
-  }
 });
 
-// 记录使用次数和内存占用的全局变量
-let usageCount = 0;
-let memoryUsage = 0;
+// 处理 GIF 的 Express 接口
+app.get('/processGif', async (req, res) => {
+    try {
+        const { gifUrl, replacementImageUrl } = req.query;
+        const tempDir = os.tmpdir();
+        const tempGifPath = path.join(tempDir, 'temp.gif');
+        const tempGifPaths = path.join(tempDir, 'temps.gif');
+        const tempVideoPath = path.join(tempDir, 'temp_video.mp4');
+        const outputGifPath = path.join(tempDir, 'output.gif');
+        const classifiersFolder = path.join(__dirname, 'classifiers');
+
+        console.log('接收到GIF处理请求:', gifUrl);
+
+        // 下载 GIF 到本地
+        console.log('开始下载GIF...');
+        const response = await axios.get(gifUrl, { responseType: 'stream' });
+        const writer = fs.createWriteStream(tempGifPath);
+        response.data.pipe(writer);
+
+        // 等待文件写入完成
+        await new Promise((resolve, reject) => {
+            writer.on('finish', resolve);
+            writer.on('error', reject);
+        });
+
+        let replacementImageBuffer = tempGifPaths
+        if (replacementImageUrl === 'replace') {
+            // 使用默认的本地替换图像路径
+            const defaultReplacementImagePath = './replacement_face.png';
+            replacementImageBuffer = await Jimp.read(defaultReplacementImagePath);
+        } else {
+            // 下载并转换替换图片到内存中
+            const response = await axios.get(replacementImageUrl, { responseType: 'stream' });
+            const writer = fs.createWriteStream(tempGifPaths);
+            response.data.pipe(writer);
+            // 等待文件写入完成
+            await new Promise((resolve, reject) => {
+                writer.on('finish', resolve);
+                writer.on('error', reject);
+            });
+            replacementImageBuffer=await Jimp.read(tempGifPaths)
+        }
+        console.log('GIF下载完成:', tempGifPath);
+
+        // 从文件夹动态加载分类器
+        const classifiers = await loadClassifiersFromFolder(classifiersFolder);
+
+        // 将GIF转换为视频
+        await gifToVideo(tempGifPath, tempVideoPath);
+
+        // 读取视频文件
+        console.log('开始读取视频文件...');
+        const videoCapture = new cv.VideoCapture(tempVideoPath);
+        const frameWidth = videoCapture.get(cv.CAP_PROP_FRAME_WIDTH);
+        const frameHeight = videoCapture.get(cv.CAP_PROP_FRAME_HEIGHT);
+        const originalFps = videoCapture.get(cv.CAP_PROP_FPS);
+        const videoWriter = new cv.VideoWriter(path.join(tempDir, 'out.mp4'), cv.VideoWriter.fourcc('avc1'), originalFps, new cv.Size(frameWidth, frameHeight));
+        console.log('视频文件读取完成');
+
+        // 处理每一帧
+        console.log('开始处理每一帧...');
+        while (true) {
+            const frame = videoCapture.read();
+            if (frame.empty) break;
 
+            const grayFrame = frame.bgrToGray();
+            const faces = [];
+            classifiers.forEach(classifier => {
+                const allfaces = classifier.detectMultiScale(grayFrame).objects;
+                faces.push(...allfaces);
+            });
+
+            const replacementFace = replacementImageBuffer;
+
+            if (Array.isArray(faces) && faces.length > 0) {
+                console.log(`检测到 ${faces.length} 张脸`);
+                for (const rect of faces) {
+                    const resizedSubstituteImage = await replacementFace.clone().resize(rect.width, rect.height);
+                    const substituteRegion = frame.getRegion(rect);
+                    for (let y = 0; y < rect.height; y++) {
+                        for (let x = 0; x < rect.width; x++) {
+                            const { r, g, b, a } = Jimp.intToRGBA(resizedSubstituteImage.getPixelColor(x, y));
+                            if (a > 0) {
+                                const color = new cv.Vec3(b, g, r);
+                                substituteRegion.set(y, x, color);
+                            }
+                        }
+                    }
+                }
+            } else {
+                console.error('未检测到人脸或faces数组为空');
+            }
+
+            videoWriter.write(frame);
+        }
+
+        videoCapture.release();
+        videoWriter.release();
+        cv.destroyAllWindows();
+        console.log('帧处理完成');
+
+        await videoToGif(path.join(tempDir, 'out.mp4'), outputGifPath);
+
+        res.set('Content-Type', 'image/gif');
+        res.sendFile(outputGifPath, async (err) => {
+            if (err) {
+                console.error('发送GIF文件时出错:', err);
+                res.status(500).send('内部服务器错误');
+            } else {
+                // 删除临时文件
+                fs.unlinkSync(tempGifPath);
+                fs.unlinkSync(tempGifPaths);
+                fs.unlinkSync(tempVideoPath);
+                fs.unlinkSync(outputGifPath);
+            }
+        });
+    } catch (error) {
+        console.error('处理GIF时出错:', error);
+        res.status(500).send('内部服务器错误');
+    }
+});
 app.use(serveStatic(__dirname)); // 添加这一行，设置静态文件服务器
 app.get('/', (req, res) => {
-  res.sendFile(path.join(__dirname, 'index.html')); // 修改这一行，发送HTML文件
+    res.sendFile(path.join(__dirname, 'index.html')); // 修改这一行，发送HTML文件
+});
+// 启动 Express 服务器
+app.listen(PORT, () => {
+    console.log(`服务器运行在端口 ${PORT}`);
 });
-
-app.listen(port, () => {
-    console.log(`Server is running on http://localhost:${port}`);
-  });