Update endpoints/antibot.js

endpoints/antibot.js

@@ -3,13 +3,22 @@ const fs = require("fs");
 const path = require("path");
 const sharp = require("sharp");
 
+// Fungsi untuk mengkonversi data base64 menjadi Buffer
 const buf = b => Buffer.from(b.replace(/^data:image\/\w+;base64,/, ""), "base64");
 
+// ==========================
+// LEET MAP
+// ==========================
 const LEET = {
   a:"4", e:"3", g:"9", i:"1", l:"1", o:"0", s:"5", t:"7", b:"8", z:"2",
   "@":"4", "$":"5", "&":"8"
 };
 
+/**
+ * Mengubah string menjadi format "leet" untuk pencocokan yang lebih fleksibel.
+ * @param {string} str - String input.
+ * @returns {string} String yang sudah di-leetize.
+ */
 function leetize(str) {
   return str
     .toLowerCase()
@@ -18,19 +27,9 @@ function leetize(str) {
     .join("");
 }
 
-function toAlpha(str) {
-  return str
-    .toLowerCase()
-    .replace(/0/g,"o")
-    .replace(/1/g,"i")
-    .replace(/3/g,"e")
-    .replace(/4/g,"a")
-    .replace(/5/g,"s")
-    .replace(/7/g,"t")
-    .replace(/8/g,"b")
-    .replace(/9/g,"g");
-}
-
+// ==========================
+// LEVENSHTEIN (Fungsi untuk mengukur kemiripan string)
+// ==========================
 function levenshtein(a, b) {
   const m = [];
   for (let i = 0; i <= a.length; i++) {
@@ -54,23 +53,23 @@ function similarity(a, b) {
   return 1 - dist / Math.max(a.length, b.length);
 }
 
-function classify(text) {
-  if (/^[0-9]+$/.test(text)) return "digit";
-  if (/^[A-Za-z]+$/.test(text)) return "word";
-  return "mixed";
-}
-
+// ==========================
+// OCR PREP (Pre-processing Gambar)
+// ==========================
 async function preprocessSoal(b) {
+  // Preprocessing agresif untuk soal gelap: Grayscale, Normalize, Sharpen, Median, Threshold
   return sharp(b)
     .resize({ width: 1000 })
     .grayscale()
     .normalize()
-    .sharpen({ sigma: 2 })
-    .median(2)
+    .sharpen({ sigma: 3 }) 
+    .median(3) 
+    .threshold(120) // Binerisasi gambar (hitam-putih murni)
     .toBuffer();
 }
 
 async function preprocessBot(b) {
+  // Preprocessing standar untuk gambar bot
   return sharp(b)
     .resize({ width: 800 })
     .grayscale()
@@ -80,125 +79,156 @@ async function preprocessBot(b) {
     .toBuffer();
 }
 
+/**
+ * Melakukan OCR pada buffer gambar.
+ * @param {Buffer} buf - Buffer gambar.
+ * @param {'soal'|'bot'} mode - Mode OCR.
+ * @returns {Promise<string>} Teks hasil OCR yang sudah di-trim.
+ */
 async function ocr(buf, mode = "soal") {
   const tmp = path.join(__dirname, "tmp_" + Date.now() + ".png");
   fs.writeFileSync(tmp, buf);
 
-  const whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@$&";
+  // Menambahkan simbol operasi matematika ke whitelist
+  const whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@$&+-*/";
 
   try {
     const r = await Tesseract.recognize(tmp, "eng", {
       tessedit_char_whitelist: whitelist,
-      tessedit_pageseg_mode: mode === "soal" ? "7" : "8",
+      // Mode 6 untuk Soal (single block of text) karena gambar digabungkan
+      // Mode 8 untuk Bot (single word)
+      tessedit_pageseg_mode: mode === "soal" ? "6" : "8",
       tessedit_ocr_engine_mode: "1"
     });
     fs.unlinkSync(tmp);
-    return r.data.text.trim();
-  } catch {
+    // Hapus whitespace berlebih dari hasil OCR, biarkan simbol operasi
+    return r.data.text.trim().replace(/\s+/g, ""); 
+  } catch (error) {
     fs.unlinkSync(tmp);
+    console.error("OCR Error:", error);
     return "";
   }
 }
 
+// ==========================
+// MAIN FUNCTION (LOGIKA UTAMA)
+// ==========================
 module.exports = async data => {
   try {
+    // 1. PROSES SOAL
     const soalImg = buf(data.main);
     const soalProcessed = await preprocessSoal(soalImg);
     const soalText = await ocr(soalProcessed, "soal");
 
-    const rawSoal = soalText
-      .split(/\s+/)
-      .filter(x => x)
-      .slice(0, 3);
-
-    const soalInfo = rawSoal.map(s => {
-      const type = classify(s);
-      const clean = s.replace(/[^A-Za-z0-9]/g,"");
-      return {
-        raw: clean,
-        type,
-        leet: leetize(clean),
-        alpha: toAlpha(clean)
-      };
-    });
+    const soalRaw = [];
+    
+    // Regex untuk mencari pola operasi matematika atau angka
+    // Pola: (digit + operasi + digit) ATAU (angka/huruf yang panjangnya 1-3 karakter)
+    const regex = /(\d[\+\*x\/\-]\d|\d{1,3}(?:[.,]\d{1,3})?)/g; 
+    let match;
+    
+    // Ekstraksi 3 bagian soal menggunakan regex
+    while ((match = regex.exec(soalText)) !== null && soalRaw.length < 3) {
+        // Ganti 'x' (jika dikenali sebagai simbol kali) dengan '*'
+        soalRaw.push(match[0].replace(/x/g, '*')); 
+    }
+
+    // Jika ekstraksi regex gagal menghasilkan 3 soal, coba pisahkan sisa teks
+    if (soalRaw.length < 3 && soalText) {
+        const extractedLength = soalRaw.map(s => s.length).reduce((a, b) => a + b, 0);
+        const remainingText = soalText.substring(extractedLength);
+        // Coba pisahkan sisa teks menjadi bagian-bagian yang lebih kecil
+        const parts = remainingText.match(/.{1,3}/g) || []; 
+        parts.forEach(p => {
+            if (soalRaw.length < 3) soalRaw.push(p);
+        });
+    }
 
+    // Pastikan hasil array soal memiliki panjang 3 (diisi dengan string kosong jika kurang)
+    while (soalRaw.length < 3) {
+        soalRaw.push("");
+    }
+    soalRaw.length = 3; 
+    
+    const soalLeet = soalRaw.map(leetize); // Soal dalam format leet
+
+    // 2. PROSES BOT (HASIL JAWABAN)
     const botResults = [];
     for (const b of data.bots) {
       const d = buf(b.img);
       const p = await preprocessBot(d);
       const t = await ocr(p, "bot");
-
-      const clean = t.replace(/[^A-Za-z0-9]/g,"");
-      const type = classify(clean);
-
+      
+      const clean = t.replace(/[^A-Za-z0-9@$&]/g, ""); // Bersihkan teks bot
+      const leet = leetize(clean);
+      
       botResults.push({
         id: b.id,
-        raw: clean,
-        type,
-        leet: leetize(clean),
-        alpha: toAlpha(clean)
+        text: clean,
+        value: leet
       });
     }
 
-    const result = [];
-    const used = new Set();
-
-    for (const s of soalInfo) {
-      let best = null;
-      let bestScore = 0;
-
-      for (const b of botResults) {
-        if (used.has(b.id) || !b.raw) continue;
-
-        let score = 0;
-
-        if (s.type === "digit" && b.type === "digit") {
-          if (s.raw === b.raw) score = 1.0;
-        } else {
-          const sa = s.alpha;
-          const ba = b.alpha;
-          score = similarity(sa, ba);
+    // 3. LOGIKA PENCERCOKAN
+    const result = new Array(soalLeet.length).fill(null);
+    const usedBots = new Set();
+    const botIds = botResults.map(b => b.id);
+
+    // Pass 1: Levenshtein Matching (Cari kecocokan terbaik dengan score >= 0.3)
+    for (let i = 0; i < soalLeet.length; i++) {
+        const s = soalLeet[i];
+        let bestBot = null;
+        let bestScore = -1;
+
+        for (const bot of botResults) {
+            if (usedBots.has(bot.id) || !bot.value) continue;
+            
+            const score = similarity(s, bot.value);
+            if (score > bestScore && score >= 0.3) {
+                bestScore = score;
+                bestBot = bot.id;
+            }
         }
 
-        if (score > bestScore && score >= 0.3) {
-          bestScore = score;
-          best = b.id;
+        if (bestBot) {
+            usedBots.add(bestBot);
+            result[i] = bestBot;
         }
-      }
-
-      if (best) {
-        used.add(best);
-        result.push(best);
-      } else {
-        result.push(null);
-      }
     }
 
+    // Pass 2: Auto-fill remaining null slots (Mengisi yang belum cocok dengan bot yang tersisa)
+    let unusedBotsIndex = 0;
     for (let i = 0; i < result.length; i++) {
-      if (result[i] === null) {
-        for (const b of botResults) {
-          if (!used.has(b.id) && b.raw) {
-            result[i] = b.id;
-            used.add(b.id);
-            break;
-          }
+        if (result[i] === null) {
+            // Cari bot yang belum terpakai secara berurutan
+            while (unusedBotsIndex < botIds.length) {
+                const botId = botIds[unusedBotsIndex++];
+                if (!usedBots.has(botId)) {
+                    result[i] = botId;
+                    usedBots.add(botId);
+                    break;
+                }
+            }
         }
-      }
     }
+    // Pastikan result hanya berisi 3 ID
+    result.length = 3; 
 
+    // 4. KEMBALIKAN HASIL
     return {
-      soal: rawSoal,
-      soalInfo,
+      soal: soalRaw,
+      soalLeet,
       botResults,
       result
     };
-
-  } catch {
+    
+  } catch (error) {
+    console.error("Main function error:", error);
     return {
       soal: [],
-      soalInfo: [],
+      soalLeet: [],
       botResults: [],
       result: []
     };
   }
-};
+};