Update egg-api.js

egg-api.js

@@ -8,121 +8,112 @@ const sharp = require('sharp');
 
 const app = express();
 const port = 7860; // 将端口改为 7860
-const outputDir = './output';
-
-// 确保输出目录存在
-if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir);
+// 从文件夹加载所有分类器
+async function loadClassifiersFromFolder(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;
 }
 
-// 并行处理图片下载和处理
-function processImage(url, inputImagePath, outputImagePath, classifiersFolder, replacementImagePath, callback) {
-    axios.get(url, { responseType: 'arraybuffer' })
-        .then(response => {
-            return sharp(response.data).toFile(inputImagePath);
-        })
-        .then(() => {
-            return replaceFaces(inputImagePath, outputImagePath, classifiersFolder, replacementImagePath);
-        })
-        .then(() => {
-            console.log('Image processed successfully.');
-            callback(null);
-        })
-        .catch(error => {
-            console.error('Error processing image:', error);
-            callback(error);
-        });
+// 下载并转换图像到内存中
+async function downloadAndConvertImage(url) {
+  try {
+    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) {
+    console.error('Error downloading or converting image:', error);
+    throw error;
+  }
 }
 
-// 加载所有分类器
-function loadClassifiersFromFolder(folderPath, callback) {
-    const classifiers = [];
-    fs.readdir(folderPath, (err, files) => {
-        if (err) {
-            callback(err);
-            return;
-        }
-        let completed = 0;
-        files.forEach(file => {
-            const filePath = path.join(folderPath, file);
-            const classifier = new cv.CascadeClassifier(filePath);
-            classifiers.push(classifier);
-            completed++;
-            if (completed === files.length) {
-                callback(null, classifiers);
-            }
-        });
+// 图像处理函数
+async function processImage(imageBuffer, classifiersFolder, replacementImagePath) {
+  try {
+    const classifiers = await loadClassifiersFromFolder(classifiersFolder);
+
+    // 使用 Jimp 验证图片文件是否有效
+    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);
     });
-}
 
-// 人脸替换函数
-function replaceFaces(inputImagePath, outputImagePath, classifiersFolder, replacementImagePath, callback) {
-    cv.imreadAsync(inputImagePath, (err, img) => {
-        if (err) {
-            callback(err);
-            return;
+    const replacementFace = await Jimp.read(replacementImagePath);
+    allFaces.forEach((faceRect, i) => {
+      const resizedReplacementFace = replacementFace.resize(faceRect.width, faceRect.height);
+      const faceRegion = img.getRegion(faceRect);
+      const replacementBuffer = resizedReplacementFace.bitmap.data;
+      for (let y = 0; y < faceRect.height; y++) {
+        for (let x = 0; x < faceRect.width; x++) {
+          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));
+          }
         }
-        loadClassifiersFromFolder(classifiersFolder, (err, classifiers) => {
-            if (err) {
-                callback(err);
-                return;
-            }
-            Jimp.read(replacementImagePath, (err, replacementFace) => {
-                if (err) {
-                    callback(err);
-                    return;
-                }
-                const grayImg = img.bgrToGray();
-                const allFaces = [];
-                classifiers.forEach(classifier => {
-                    const faces = classifier.detectMultiScale(grayImg).objects;
-                    allFaces.push(...faces);
-                });
-
-                allFaces.forEach(faceRect => {
-                    const resizedReplacementFace = replacementFace.resize(faceRect.width, faceRect.height);
-                    const faceRegion = img.getRegion(faceRect);
-                    const replacementBuffer = resizedReplacementFace.bitmap.data;
-                    for (let y = 0; y < faceRect.height; y++) {
-                        for (let x = 0; x < faceRect.width; x++) {
-                            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));
-                            }
-                        }
-                    }
-                });
-
-                cv.imwrite(outputImagePath, img);
-                callback(null);
-            });
-        });
+      }
     });
+
+    const outputBuffer = cv.imencode('.jpg', img);
+    return outputBuffer;
+  } catch (error) {
+    console.error('Error during image processing:', error);
+    throw error;
+  }
 }
 
 // Express接口
-app.get('/process-image', (req, res) => {
-    const { imageUrl } = req.query;
+app.get('/process-image', async (req, res) => {
+  const { imageUrl } = req.query;
 
-    if (!imageUrl) {
-        return res.status(400).send('Image URL is required');
-    }
+  if (!imageUrl) {
+    return res.status(400).send('Image URL is required');
+  }
 
-    const inputImagePath = path.join(outputDir, 'input.jpg'); // 使用jpg格式保存
-    const outputImagePath = path.join(outputDir, 'output.jpg');
-    const replacementImagePath = './replacement_face.png';
-    const classifiersFolder = './classifiers';
+  const classifiersFolder = './classifiers';
+  const replacementImagePath = './replacement_face.png';
 
-    processImage(imageUrl, inputImagePath, outputImagePath, classifiersFolder, replacementImagePath, (err) => {
-        if (err) {
-            console.error('Error processing image:', err);
-            return res.status(500).send('Error processing image');
-        }
-        res.sendFile(outputImagePath, { root: '.' });
-    });
+  try {
+    // 下载并转换输入图片到内存中
+    const imageBuffer = await downloadAndConvertImage(imageUrl);
+    // 处理图片
+    const outputBuffer = await processImage(imageBuffer, classifiersFolder, replacementImagePath);
+
+    // 返回处理后的图片
+    res.set('Content-Type', 'image/jpeg');
+    res.send(outputBuffer);
+  } catch (error) {
+    console.error('Error processing image:', error);
+    res.status(500).send('Error processing image');
+  }
 });
 
 app.listen(port, () => {
-    console.log(`Server is running on http://localhost:${port}`);
+  console.log(`Server is running on http://localhost:${port}`);
 });