Update egg-api.js

egg-api.js

@@ -16,67 +16,93 @@ if (!fs.existsSync(outputDir)) {
 }
 
 // 并行处理图片下载和处理
-async function processImage(url, inputImagePath, outputImagePath, classifiersFolder, replacementImagePath) {
-    try {
-        // 下载并转换输入图片
-        const response = await axios.get(url, { responseType: 'arraybuffer' });
-        await sharp(response.data).toFile(inputImagePath);
-
-        // 图片下载和转换完成后进行人脸替换
-        await replaceFaces(inputImagePath, outputImagePath, classifiersFolder, replacementImagePath);
-
-        console.log('Image processed successfully.');
-    } catch (error) {
-        console.error('Error processing image:', error);
-        throw error;
-    }
+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 loadClassifiersFromFolder(folderPath) {
+function loadClassifiersFromFolder(folderPath, callback) {
     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;
+    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 replaceFaces(inputImagePath, outputImagePath, classifiersFolder, replacementImagePath) {
-    const img = cv.imread(inputImagePath);
-    const classifiers = await loadClassifiersFromFolder(classifiersFolder);
-    const replacementFace = await Jimp.read(replacementImagePath);
+function replaceFaces(inputImagePath, outputImagePath, classifiersFolder, replacementImagePath, callback) {
+    cv.imreadAsync(inputImagePath, (err, img) => {
+        if (err) {
+            callback(err);
+            return;
+        }
+        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);
+                });
 
-    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));
+                            }
+                        }
+                    }
+                });
 
-    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);
+            });
+        });
     });
-
-    cv.imwrite(outputImagePath, img);
 }
 
 // Express接口
-app.get('/process-image', async (req, res) => {
+app.get('/process-image', (req, res) => {
     const { imageUrl } = req.query;
 
     if (!imageUrl) {
@@ -88,13 +114,13 @@ app.get('/process-image', async (req, res) => {
     const replacementImagePath = './replacement_face.png';
     const classifiersFolder = './classifiers';
 
-    try {
-        await processImage(imageUrl, inputImagePath, outputImagePath, classifiersFolder, replacementImagePath);
+    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: '.' });
-    } catch (error) {
-        console.error('Error processing image:', error);
-        res.status(500).send('Error processing image');
-    }
+    });
 });
 
 app.listen(port, () => {