Update egg-api.js

egg-api.js

@@ -1,16 +1,17 @@
 const express = require('express');
-const fs = require('fs');
-const path = require('path');
 const cv = require('opencv4nodejs');
 const Jimp = require('jimp');
+const ffmpeg = require('fluent-ffmpeg');
 const axios = require('axios');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const Jimp = require('jimp');
 const sharp = require('sharp');
 const serveStatic = require('serve-static');
-const ffmpeg = require('fluent-ffmpeg');
 
 const app = express();
-const port = 7860;
-
+const PORT = 7860;
 // 从文件夹加载所有分类器
 const loadClassifiersFromFolder = async (folderPath) => {
   const classifiers = [];
@@ -26,148 +27,110 @@ const loadClassifiersFromFolder = async (folderPath) => {
 // 下载并转换图像到内存中
 const downloadAndConvertImage = async (url) => {
   try {
-    const response = await axios.get(url, { responseType: 'arraybuffer' });
-    return await sharp(response.data).toFormat('jpeg').toBuffer();
+    const response = await axios({
+      method: 'get',
+      url: url,
+      responseType: 'arraybuffer'
+    });
+
+    const imageBuffer = await sharp(response.data)
+      .toFormat('jpeg')
+      .toBuffer();
+
+    console.log('Image downloaded and converted successfully.');
+    return imageBuffer;
   } catch (error) {
-    throw new Error('Error downloading or converting image: ' + error.message);
+    console.error('Error downloading or converting image:', error);
+    throw error;
   }
 };
 
 // 图像处理函数
 const processImage = async (imageBuffer, classifiersFolder, replacementImageBuffer) => {
-  const classifiers = await loadClassifiersFromFolder(classifiersFolder);
-  const img = cv.imdecode(imageBuffer);
-  const grayImg = img.bgrToGray();
-  const allFaces = classifiers.flatMap(classifier => classifier.detectMultiScale(grayImg).objects);
-
-  if (allFaces.length === 0) throw new Error('No faces detected in the image.');
-
-  const replacementFace = await Jimp.read(replacementImageBuffer);
-  allFaces.forEach((faceRect) => {
-    const resizedReplacementFace = replacementFace.resize(faceRect.width, faceRect.height);
-    resizedReplacementFace.scan(0, 0, resizedReplacementFace.bitmap.width, resizedReplacementFace.bitmap.height, (x, y, idx) => {
-      if (resizedReplacementFace.bitmap.data[idx + 3] > 0) {
-        img.set(faceRect.y + y, faceRect.x + x, new cv.Vec3(
-          resizedReplacementFace.bitmap.data[idx + 2],
-          resizedReplacementFace.bitmap.data[idx + 1],
-          resizedReplacementFace.bitmap.data[idx]
-        ));
-      }
-    });
-  });
-
-  return cv.imencode('.jpg', img);
-};
-
-// GIF转换为视频
-const gifToVideo = async (inputGifPath, outputVideoPath) => {
-  return new Promise((resolve, reject) => {
-    ffmpeg(inputGifPath)
-      .inputFormat('gif')
-      .output(outputVideoPath)
-      .on('end', resolve)
-      .on('error', reject)
-      .run();
-  });
-};
-
-// 视频转换为GIF
-const videoToGif = async (inputVideoPath, outputGifPath) => {
-  return new Promise((resolve, reject) => {
-    ffmpeg(inputVideoPath)
-      .output(outputGifPath)
-      .on('end', resolve)
-      .on('error', reject)
-      .run();
-  });
-};
-
-// 处理 GIF 的接口
-app.get('/processGif', async (req, res) => {
-  const { gifUrl } = req.query;
-
-  if (!gifUrl) {
-    return res.status(400).send('GIF URL is required');
-  }
-
-  const tempDir = path.join(__dirname, 'temp');
-  const tempGifPath = path.join(tempDir, 'temp.gif');
-  const tempVideoPath = path.join(tempDir, 'temp_video.mp4');
-  const outputGifPath = path.join(tempDir, 'output.gif');
-  const classifiersFolder = path.join(__dirname, 'classifiers');
-  const replacementImagePath = path.join(__dirname, 'replacement_face.png');
-
   try {
-    // 下载 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);
-    });
-
-    // 从文件夹动态加载分类器
     const classifiers = await loadClassifiersFromFolder(classifiersFolder);
-    await gifToVideo(tempGifPath, tempVideoPath);
-
-    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));
-
-    while (true) {
-      const frame = videoCapture.read();
-      if (frame.empty) break;
-
-      const grayFrame = frame.bgrToGray();
-      const faces = classifiers.flatMap(classifier => classifier.detectMultiScale(grayFrame).objects);
-
-      const replacementFace = await Jimp.read(replacementImagePath);
-      if (faces.length > 0) {
-        faces.forEach(rect => {
-          const resizedSubstituteImage = replacementFace.resize(rect.width, rect.height);
-          resizedSubstituteImage.scan(0, 0, resizedSubstituteImage.bitmap.width, resizedSubstituteImage.bitmap.height, (x, y, idx) => {
-            if (resizedSubstituteImage.bitmap.data[idx + 3] > 0) {
-              frame.set(rect.y + y, rect.x + x, new cv.Vec3(
-                resizedSubstituteImage.bitmap.data[idx + 2],
-                resizedSubstituteImage.bitmap.data[idx + 1],
-                resizedSubstituteImage.bitmap.data[idx]
-              ));
+  
+    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 grayImg = img.bgrToGray();
+    const allFaces = [];
+    classifiers.forEach(classifier => {
+      const faces = classifier.detectMultiScale(grayImg).objects;
+      allFaces.push(...faces);
+    });
+  
+    // 如果没有检测到人脸，抛出错误
+    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));
             }
-          });
-        });
+          }
+        }
       }
-
-      videoWriter.write(frame);
-    }
-
-    videoCapture.release();
-    videoWriter.release();
-    await videoToGif(path.join(tempDir, 'out.mp4'), outputGifPath);
-
-    res.set('Content-Type', 'image/gif').sendFile(outputGifPath);
+    });
+    const outputBuffer = cv.imencode('.jpg', img);
+    return outputBuffer;
   } catch (error) {
-    console.error('Error processing GIF:', error);
-    res.status(500).send('Error processing GIF');
+    console.error('Error during image processing:', error);
+    throw error;
   }
-});
+};
 
-// 图像处理接口
+// 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);
-    const replacementImageBuffer = await downloadAndConvertImage(replacementImageUrl);
+    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').send(outputBuffer);
+  
+    // 返回处理后的图片
+    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.');
@@ -178,12 +141,179 @@ app.get('/process-image', async (req, res) => {
   }
 });
 
-// 静态文件服务
-app.use(serveStatic(__dirname));
+// 记录使用次数和内存占用的全局变量
+let usageCount = 0;
+let memoryUsage = 0;
+
+app.use(serveStatic(__dirname)); // 添加这一行，设置静态文件服务器
 app.get('/', (req, res) => {
-  res.sendFile(path.join(__dirname, 'index.html'));
+  res.sendFile(path.join(__dirname, 'index.html')); // 修改这一行，发送HTML文件
 });
 
 app.listen(port, () => {
-  console.log(`Server is running on http://localhost:${port}`);
+    console.log(`Server is running on http://localhost:${port}`);
+  });
+app.use(express.json());
+
+// 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();
+    });
+}
+
+// 添加将输出视频转换为 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();
+    });
+}
+
+// 从文件夹加载所有分类器
+async function loadClassifiersFromFolder(folderPath) {
+    console.log(`开始从文件夹 ${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);
+        console.log(`加载分类器: ${file}`);
+    }
+
+    console.log('分类器加载完成');
+    return classifiers;
+}
+
+// 处理 GIF 的 Express 接口
+app.get('/processGif', async (req, res) => {
+    try {
+        const { gifUrl } = req.query;
+        const tempDir = os.tmpdir();
+        const tempGifPath = path.join(tempDir, 'temp.gif');
+        const tempVideoPath = path.join(tempDir, 'temp_video.mp4');
+        const outputGifPath = path.join(tempDir, 'output.gif');
+        const replacementImagePath = path.join(__dirname, 'replacement_face.png');
+        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);
+        });
+
+        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 = await Jimp.read(replacementImagePath);
+
+            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);
+                            }
+                        }
+                    }
+                    const buffer = await resizedSubstituteImage.getBufferAsync(Jimp.MIME_PNG);
+                    const substituteMat = cv.imdecode(Buffer.from(buffer), cv.IMREAD_UNCHANGED);
+                    substituteMat.copyTo(frame.getRegion(rect));
+                }
+            } 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);
+    } catch (error) {
+        console.error('处理GIF时出错:', error);
+        res.status(500).send('内部服务器错误');
+    }
+});
+
+
+app.listen(PORT, () => {
+    console.log(`服务器运行在端口 ${PORT}`);
 });