Update endpoints/antibot.js

endpoints/antibot.js

@@ -1,19 +1,38 @@
 const Tesseract = require("tesseract.js");
 const fs = require("fs");
 const path = require("path");
-const cv = require('opencv4nodejs');
+const sharp = require("sharp");
 
 const buf = b => Buffer.from(b.replace(/^data:image\/\w+;base64,/, ""), "base64");
 
 // ==========================
-// LEET MAP
+// LEET MAP & UTILITIES
 // ==========================
 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"
+  a: "4", e: "3", g: "9", i: "1", l: "1", o: "0", s: "5", t: "7", b: "8", z: "2",
+  "@": "4", "$": "5", "&": "8"
 };
 
+const REVERSE_LEET = {
+  "4": "a", "3": "e", "9": "g", "1": "i", "0": "o", "5": "s", "7": "t", "8": "b", "2": "z"
+};
+
+function isMostlyNumbers(str) {
+  if (!str) return false;
+  const numCount = (str.match(/[0-9]/g) || []).length;
+  return numCount >= str.length * 0.7; // 70% atau lebih adalah angka
+}
+
+function containsAlphabet(str) {
+  return /[a-zA-Z@$&]/.test(str);
+}
+
 function leetize(str) {
+  if (!str || isMostlyNumbers(str) && !containsAlphabet(str)) {
+    // Jika string mostly numbers dan tidak ada alfabet, return as-is
+    return str;
+  }
+  
   return str
     .toLowerCase()
     .split("")
@@ -21,73 +40,78 @@ function leetize(str) {
     .join("");
 }
 
+function normalizeText(text) {
+  return text
+    .replace(/[^A-Za-z0-9@$&]/g, "")
+    .replace(/\s+/g, "")
+    .trim();
+}
+
 // ==========================
-// OPENCV PREPROCESSING
+// LEVENSHTEIN
 // ==========================
-async function preprocessWithOpenCV(buffer) {
-  try {
-    // Decode image dari buffer
-    let img = cv.imdecode(buffer);
-    
-    // 1. Resize untuk improve quality
-    img = img.resize(new cv.Size(0, 0), 2, 2, cv.INTER_CUBIC);
-    
-    // 2. Convert ke grayscale
-    let gray = img.bgrToGray();
-    
-    // 3. Gaussian blur untuk noise reduction
-    let blurred = gray.gaussianBlur(new cv.Size(3, 3), 0);
-    
-    // 4. Adaptive threshold (lebih baik dari global threshold)
-    let thresh = blurred.adaptiveThreshold(
-      255,
-      cv.ADAPTIVE_THRESH_GAUSSIAN_C,
-      cv.THRESH_BINARY,
-      11,
-      2
-    );
-    
-    // 5. Morphological operations untuk bersihkan noise
-    let kernel = cv.getStructuringElement(cv.MORPH_RECT, new cv.Size(2, 2));
-    let cleaned = thresh.morphologyEx(kernel, cv.MORPH_CLOSE);
-    
-    // 6. Dilate untuk teks lebih tebal
-    kernel = cv.getStructuringElement(cv.MORPH_RECT, new cv.Size(1, 1));
-    let dilated = cleaned.dilate(kernel);
-    
-    // Encode kembali ke buffer
-    return cv.imencode('.png', dilated).toString('base64');
-    
-  } catch (error) {
-    console.error("OpenCV Preprocessing error:", error);
-    return buffer; // Fallback ke original
+function levenshtein(a, b) {
+  if (!a || !b) return Math.max(a?.length || 0, b?.length || 0);
+  
+  const m = [];
+  for (let i = 0; i <= a.length; i++) {
+    m[i] = [i];
+    for (let j = 1; j <= b.length; j++) {
+      m[i][j] =
+        i === 0
+          ? j
+          : Math.min(
+              m[i - 1][j] + 1,
+              m[i][j - 1] + 1,
+              m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+            );
+    }
   }
+  return m[a.length][b.length];
+}
+
+function similarity(a, b) {
+  if (!a || !b) return 0;
+  const dist = levenshtein(a, b);
+  const maxLen = Math.max(a.length, b.length);
+  return maxLen === 0 ? 1 : 1 - dist / maxLen;
 }
 
 // ==========================
-// OCR WITH OPENCV PREPROCESSING
+// OCR PREP
 // ==========================
-async function ocrWithOpenCV(buffer, mode = "soal") {
-  // Preprocess dengan OpenCV
-  const processedBase64 = await preprocessWithOpenCV(buffer);
-  const processedBuffer = Buffer.from(processedBase64, 'base64');
-  
-  const tmp = path.join(__dirname, "opencv_processed_" + Date.now() + ".png");
-  fs.writeFileSync(tmp, processedBuffer);
+async function preprocessSoal(b) {
+  return sharp(b)
+    .resize({ width: 1000 })
+    .grayscale()
+    .normalize()
+    .sharpen({ sigma: 2 })
+    .median(2)
+    .toBuffer();
+}
+
+async function preprocessBot(b) {
+  return sharp(b)
+    .resize({ width: 800 })
+    .grayscale()
+    .normalize()
+    .sharpen({ sigma: 1.5 })
+    .median(1)
+    .toBuffer();
+}
+
+async function ocr(buf, mode = "soal") {
+  const tmp = path.join(__dirname, "tmp_" + Date.now() + ".png");
+  fs.writeFileSync(tmp, buf);
+
+  const whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@$&";
 
   try {
-    const config = {
+    const r = await Tesseract.recognize(tmp, "eng", {
+      tessedit_char_whitelist: whitelist,
       tessedit_pageseg_mode: mode === "soal" ? "7" : "8",
       tessedit_ocr_engine_mode: "1"
-    };
-
-    if (mode === "soal") {
-      config.tessedit_char_whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@$&";
-    } else {
-      config.tessedit_char_whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    }
-
-    const r = await Tesseract.recognize(tmp, "eng", config);
+    });
     fs.unlinkSync(tmp);
     return r.data.text.trim();
   } catch (error) {
@@ -98,46 +122,56 @@ async function ocrWithOpenCV(buffer, mode = "soal") {
 }
 
 // ==========================
-// TEXT CLEANING
+// MATCHING STRATEGIES
 // ==========================
-function cleanText(text) {
-  return text.replace(/[^A-Za-z0-9]/g, '');
-}
+function findBestMatch(soalText, botResults, usedBots, minScore = 0.3) {
+  let bestBot = null;
+  let bestScore = 0;
 
-// ==========================
-// LEVENSHTEIN SIMILARITY
-// ==========================
-function levenshtein(a, b) {
-  const m = [];
-  for (let i = 0; i <= a.length; i++) {
-    m[i] = [i];
-    for (let j = 1; j <= b.length; j++) {
-      m[i][j] =
-        i === 0
-          ? j
-          : Math.min(
-              m[i - 1][j] + 1,
-              m[i][j - 1] + 1,
-              m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
-            );
+  for (const bot of botResults) {
+    if (usedBots.has(bot.id) || !bot.value) continue;
+    
+    const score = similarity(soalText, bot.value);
+    if (score > bestScore && score >= minScore) {
+      bestScore = score;
+      bestBot = bot.id;
     }
   }
-  return m[a.length][b.length];
+
+  return { bestBot, bestScore };
 }
 
-function similarity(a, b) {
-  const dist = levenshtein(a, b);
-  return 1 - dist / Math.max(a.length, b.length);
+function analyzeTextType(texts) {
+  const analysis = {
+    total: texts.length,
+    numericCount: 0,
+    alphaCount: 0,
+    mixedCount: 0
+  };
+
+  for (const text of texts) {
+    if (isMostlyNumbers(text) && !containsAlphabet(text)) {
+      analysis.numericCount++;
+    } else if (containsAlphabet(text)) {
+      analysis.alphaCount++;
+    } else {
+      analysis.mixedCount++;
+    }
+  }
+
+  analysis.isMostlyNumeric = analysis.numericCount > analysis.total * 0.5;
+  return analysis;
 }
 
 // ==========================
-// MAIN FUNCTION - OPENCV + LEET
+// MAIN - IMPROVED MATCHING
 // ==========================
 module.exports = async data => {
   try {
-    // SOAL - Pakai OpenCV preprocessing + Leet
+    // SOAL OCR
     const soalImg = buf(data.main);
-    const soalText = await ocrWithOpenCV(soalImg, "soal");
+    const soalProcessed = await preprocessSoal(soalImg);
+    const soalText = await ocr(soalProcessed, "soal");
 
     const soalRaw = soalText
       .split(/\s+/)
@@ -145,65 +179,80 @@ module.exports = async data => {
       .slice(0, 3);
 
     const soalLeet = soalRaw.map(leetize);
+    
+    // Analisis tipe teks soal
+    const soalAnalysis = analyzeTextType(soalRaw);
 
-    // BOT - Pakai OpenCV preprocessing (TANPA LEET)
+    // BOT OCR
     const botResults = [];
     for (const b of data.bots) {
-      const botImg = buf(b.img);
-      const botText = await ocrWithOpenCV(botImg, "bot");
+      const d = buf(b.img);
+      const p = await preprocessBot(d);
+      const t = await ocr(p, "bot");
       
-      const cleanText = cleanText(botText);
+      const clean = normalizeText(t);
+      const leet = leetize(clean);
       
       botResults.push({
         id: b.id,
-        text: cleanText,
-        value: cleanText, // Tetap asli, tidak di-leet
-        originalOCR: botText
+        text: clean,
+        value: leet,
+        isNumeric: isMostlyNumbers(clean) && !containsAlphabet(clean)
       });
     }
 
-    console.log("=== DEBUG OPENCV ===");
-    console.log("Soal Raw:", soalRaw);
-    console.log("Soal Leet:", soalLeet);
-    console.log("Bot Results:", botResults.map(b => ({ id: b.id, value: b.value })));
-
-    // MATCHING LOGIC
+    // IMPROVED MATCHING LOGIC
     const result = [];
     const usedBots = new Set();
 
-    // First pass: exact match atau similarity tinggi
-    for (const s of soalLeet) {
-      let bestBot = null;
-      let bestScore = 0;
-
-      for (const bot of botResults) {
-        if (usedBots.has(bot.id) || !bot.value) continue;
-        
-        const score = similarity(s, bot.value);
-        console.log(`Matching "${s}" with bot ${bot.id} ("${bot.value}") = ${score}`);
-        
-        if (score > bestScore) {
-          bestScore = score;
-          bestBot = bot.id;
-        }
+    console.log("Soal Analysis:", soalAnalysis);
+    console.log("Soal Raw:", soalRaw);
+    console.log("Soal Leet:", soalLeet);
+    console.log("Bot Results:", botResults.map(b => ({ id: b.id, text: b.text, value: b.value, isNumeric: b.isNumeric })));
+
+    // First pass: cari match terbaik dengan threshold yang disesuaikan
+    for (let i = 0; i < soalLeet.length; i++) {
+      const currentSoal = soalLeet[i];
+      const currentSoalRaw = soalRaw[i];
+      
+      // Adjust threshold berdasarkan tipe konten
+      let minScore = 0.3;
+      if (isMostlyNumbers(currentSoalRaw) && !containsAlphabet(currentSoalRaw)) {
+        minScore = 0.6; // Lebih ketat untuk angka murni
       }
 
-      // Threshold lebih rendah karena OpenCV sudah lebih akurat
-      if (bestBot && bestScore >= 0.2) {
+      const { bestBot, bestScore } = findBestMatch(currentSoal, botResults, usedBots, minScore);
+
+      if (bestBot) {
+        console.log(`Match found: Soal "${currentSoal}" -> Bot ${bestBot} (score: ${bestScore.toFixed(3)})`);
         usedBots.add(bestBot);
         result.push(bestBot);
       } else {
+        console.log(`No good match for: "${currentSoal}", will auto-fill later`);
         result.push(null);
       }
     }
 
-    // Auto-fill remaining
+    // Second pass: auto-fill remaining slots dengan unused bots
+    const unusedBots = botResults.filter(bot => !usedBots.has(bot.id) && bot.value);
+    
+    for (let i = 0; i < result.length; i++) {
+      if (result[i] === null && unusedBots.length > 0) {
+        const bot = unusedBots.shift();
+        result[i] = bot.id;
+        usedBots.add(bot.id);
+        console.log(`Auto-filled slot ${i} with bot ${bot.id}`);
+      }
+    }
+
+    // Final fallback: jika masih ada null, isi dengan bot yang tersisa (termasuk yang sudah digunakan jika perlu)
     for (let i = 0; i < result.length; i++) {
       if (result[i] === null) {
         for (const bot of botResults) {
-          if (!usedBots.has(bot.id) && bot.value) {
+          if (!usedBots.has(bot.id) || result.filter(x => x === bot.id).length === 0) {
             result[i] = bot.id;
             usedBots.add(bot.id);
+            console.log(`Fallback filled slot ${i} with bot ${bot.id}`);
             break;
           }
         }
@@ -213,8 +262,9 @@ module.exports = async data => {
     return {
       soal: soalRaw,
       soalLeet,
-      botResults,
-      result
+      botResults: botResults.map(b => ({ id: b.id, text: b.text, value: b.value })),
+      result,
+      analysis: soalAnalysis
     };
     
   } catch (error) {
@@ -223,7 +273,8 @@ module.exports = async data => {
       soal: [],
       soalLeet: [],
       botResults: [],
-      result: []
+      result: [],
+      analysis: {}
     };
   }
 };