""" KTP Field Extractor Ekstraksi data terstruktur dari hasil OCR KTP Indonesia Mendukung berbagai format output OCR (full-width colon, standard colon, tanpa colon) OPTIMIZED: Pre-compiled regex patterns for better performance """ import re from typing import Dict, Optional, List import difflib # Debug mode - set to False for production DEBUG_MODE = False class KTPExtractor: """Ekstrak field dari hasil OCR KTP""" # Pre-compiled regex patterns (optimization) COLON_PATTERN = re.compile(r'[：:]') NIK_PATTERN = re.compile(r'\b(\d{16})\b') DATE_PATTERN = re.compile(r'(\d{2}[-/]\d{2}[-/]\d{4})') RT_RW_PATTERN = re.compile(r'(\d{3})\s*/\s*(\d{3})') GOL_DARAH_PATTERN = re.compile(r'([ABO]{1,2}[+\-]?)', re.IGNORECASE) PROVINSI_SPLIT_PATTERN = re.compile(r'(?i)provinsi\s*') KABUPATEN_SPLIT_PATTERN = re.compile(r'(?i)\s*(kabupaten|kota)\s*') TTL_PATTERN = re.compile(r'(?i)tempat[/\s]*tgl[/\s]*lahir|tempat[/\s]*lahir|lahir') # Pattern colon string (for backward compatibility) COLON_PATTERN_STR = r'[：:]' # Daftar Provinsi Indonesia (38 Provinsi) PROVINSI_LIST = [ "ACEH", "SUMATERA UTARA", "SUMATERA BARAT", "RIAU", "JAMBI", "SUMATERA SELATAN", "BENGKULU", "LAMPUNG", "KEPULAUAN BANGKA BELITUNG", "KEPULAUAN RIAU", "DKI JAKARTA", "JAWA BARAT", "JAWA TENGAH", "DI YOGYAKARTA", "JAWA TIMUR", "BANTEN", "BALI", "NUSA TENGGARA BARAT", "NUSA TENGGARA TIMUR", "KALIMANTAN BARAT", "KALIMANTAN TENGAH", "KALIMANTAN SELATAN", "KALIMANTAN TIMUR", "KALIMANTAN UTARA", "SULAWESI UTARA", "SULAWESI TENGAH", "SULAWESI SELATAN", "SULAWESI TENGGARA", "GORONTALO", "SULAWESI BARAT", "MALUKU", "MALUKU UTARA", "PAPUA BARAT", "PAPUA", "PAPUA SELATAN", "PAPUA TENGAH", "PAPUA PEGUNUNGAN", "PAPUA BARAT DAYA" ] # Keywords untuk jenis kelamin MALE_KEYWORDS = ['laki', 'pria', 'male'] FEMALE_KEYWORDS = ['perempuan', 'wanita', 'female'] # Agama yang valid AGAMA_LIST = ['islam', 'kristen', 'katolik', 'hindu', 'budha', 'buddha', 'konghucu'] # Pekerjaan umum PEKERJAAN_LIST = ['pelajar', 'mahasiswa', 'pegawai', 'swasta', 'pns', 'wiraswasta', 'buruh', 'petani', 'nelayan', 'karyawan', 'ibu rumah tangga', 'tidak bekerja', 'lainnya', 'mengurus rumah tangga'] # Status Perkawinan yang valid STATUS_PERKAWINAN_LIST = ['BELUM KAWIN', 'KAWIN', 'CERAI HIDUP', 'CERAI MATI'] # Field Labels untuk fuzzy matching (mengatasi typo OCR seperti "Aamat" -> "ALAMAT") FIELD_LABELS = { 'nama': ['NAMA'], 'alamat': ['ALAMAT'], 'agama': ['AGAMA'], 'pekerjaan': ['PEKERJAAN'], 'kewarganegaraan': ['KEWARGANEGARAAN', 'WARGANEGARA'], 'tempat_lahir': ['TEMPAT', 'LAHIR', 'TEMPAT/TGL LAHIR'], 'jenis_kelamin': ['JENIS KELAMIN', 'JENIS', 'KELAMIN'], 'gol_darah': ['GOL. DARAH', 'GOL DARAH', 'GOLONGAN DARAH'], 'kel_desa': ['KEL/DESA', 'KELURAHAN', 'DESA'], 'kecamatan': ['KECAMATAN', 'KEC'], 'status_perkawinan': ['STATUS PERKAWINAN', 'PERKAWINAN'], 'berlaku_hingga': ['BERLAKU HINGGA', 'BERLAKU'], 'rt_rw': ['RT/RW', 'RT', 'RW'], } # ============================================ # Sistem Penamaan Hindu Bali # ============================================ # Struktur: [Prefix Gender] + [Gelar Kasta] + [Penanda Gender] + [Urutan Lahir] + [Nama Pribadi] # Prefix penanda gender (harus di awal nama) BALI_GENDER_PREFIX = { 'NI': 'PEREMPUAN', # Prefix untuk perempuan 'I': 'LAKI-LAKI', # Prefix untuk laki-laki } # Gelar Kasta (setelah prefix gender) BALI_KASTA = { 'IDA': 'BRAHMANA', 'GUSTI': 'KSATRIA', 'ANAK AGUNG': 'KSATRIA', 'COKORDA': 'KSATRIA', 'DEWA': 'KSATRIA', 'DESAK': 'KSATRIA', 'AGUNG': 'KSATRIA', 'NGAKAN': 'WAISYA', 'SANG': 'WAISYA', 'SI': 'WAISYA', } # Penanda gender tambahan (setelah kasta) BALI_GENDER_MARKER = { 'AYU': 'PEREMPUAN', 'ISTRI': 'PEREMPUAN', 'LUH': 'PEREMPUAN', 'BAGUS': 'LAKI-LAKI', 'GEDE': 'LAKI-LAKI', 'AGUS': 'LAKI-LAKI', 'ALIT': 'LAKI-LAKI', # Kecil/muda (untuk laki-laki) } # Urutan kelahiran (bersiklus setiap 4 anak) BALI_BIRTH_ORDER = { 'PUTU': 1, 'WAYAN': 1, 'GEDE': 1, 'ILUH': 1, 'MADE': 2, 'KADEK': 2, 'NENGAH': 2, 'NYOMAN': 3, 'KOMANG': 3, 'KETUT': 4, 'BALIK': 5, # Untuk anak ke-5+ (siklus ulang) } # Soroh/Klan Bali (identifikasi garis keturunan) BALI_SOROH = { 'PASEK': 'SOROH', # Klan mayoritas (~60% Hindu Bali) 'PANDE': 'SOROH', # Klan pandai besi/metalurgi 'ARYA': 'SOROH', # Klan Arya 'BENDESA': 'SOROH', # Pemimpin adat 'TANGKAS': 'SOROH', # Klan Tangkas 'CELAGI': 'SOROH', # Klan Celagi 'SENGGUHU': 'SOROH', # Klan Sengguhu 'KUBAYAN': 'SOROH', # Klan Kubayan 'BANDESA': 'SOROH', # Varian Bendesa } # Gabungkan semua komponen untuk deteksi (urut dari panjang ke pendek) BALI_NAME_COMPONENTS = [ # Prefix gender 'NI', 'I', # Kasta (prioritas: yang lebih panjang dulu) 'ANAK AGUNG', 'COKORDA', 'NGAKAN', 'IDA', 'GUSTI', 'DEWA', 'DESAK', 'AGUNG', 'SANG', 'SI', # Soroh/Klan 'PASEK', 'PANDE', 'ARYA', 'BENDESA', 'BANDESA', 'TANGKAS', 'CELAGI', 'SENGGUHU', 'KUBAYAN', # Gender marker 'AYU', 'ISTRI', 'LUH', 'BAGUS', 'GEDE', 'AGUS', 'ALIT', # Urutan lahir 'WAYAN', 'PUTU', 'ILUH', 'MADE', 'KADEK', 'NENGAH', 'NYOMAN', 'KOMANG', 'KETUT', 'BALIK', ] # KTP Zone Template (normalized coordinates: x_min, y_min, x_max, y_max) # Based on standard KTP layout ZONES = { 'header_provinsi': (0.15, 0.00, 0.85, 0.07), # PROVINSI header 'header_kabupaten': (0.15, 0.05, 0.85, 0.13), # KABUPATEN header 'nik': (0.02, 0.10, 0.70, 0.22), # NIK area 'nama': (0.02, 0.18, 0.70, 0.28), # Nama area 'ttl': (0.02, 0.25, 0.70, 0.36), # Tempat/Tgl Lahir 'jenis_kelamin': (0.02, 0.33, 0.45, 0.42), # Jenis Kelamin (left) 'gol_darah': (0.40, 0.33, 0.70, 0.42), # Gol Darah (right of jenis) 'alamat': (0.02, 0.38, 0.70, 0.50), # Alamat 'rt_rw': (0.02, 0.46, 0.70, 0.54), # RT/RW 'kel_desa': (0.02, 0.51, 0.70, 0.60), # Kel/Desa 'kecamatan': (0.02, 0.57, 0.70, 0.66), # Kecamatan 'agama': (0.02, 0.63, 0.70, 0.72), # Agama 'status': (0.02, 0.69, 0.70, 0.78), # Status Perkawinan 'pekerjaan': (0.02, 0.75, 0.70, 0.84), # Pekerjaan 'wni': (0.02, 0.81, 0.70, 0.90), # Kewarganegaraan 'berlaku': (0.02, 0.87, 0.70, 0.96), # Berlaku Hingga 'foto': (0.68, 0.10, 0.98, 0.55), # Foto (right side) 'penerbitan': (0.65, 0.58, 0.98, 0.98), # Tempat & Tanggal penerbitan } def __init__(self): self.image_width = 0 self.image_height = 0 def _get_zone(self, x_center: float, y_center: float, img_width: int, img_height: int) -> Optional[str]: """Determine which zone a text belongs to based on normalized coordinates""" if img_width == 0 or img_height == 0: return None # Normalize coordinates x_norm = x_center / img_width y_norm = y_center / img_height for zone_name, (x_min, y_min, x_max, y_max) in self.ZONES.items(): if x_min <= x_norm <= x_max and y_min <= y_norm <= y_max: return zone_name return None def _extract_value_from_text(self, text: str) -> str: """Extract value part from label:value text""" # Split by colon (standard or full-width) parts = re.split(r'[：:]', text, 1) if len(parts) > 1: return parts[1].strip() return text.strip() def _find_best_match(self, text: str, candidates: List[str], cutoff: float = 0.6) -> Optional[str]: """Find best fuzzy match from candidates""" matches = difflib.get_close_matches(text, candidates, n=1, cutoff=cutoff) return matches[0] if matches else None def _is_label_match(self, text: str, field_name: str, cutoff: float = 0.7) -> bool: """ Fuzzy match untuk label field - mengatasi typo OCR seperti "Aamat" -> "ALAMAT" Returns True jika text cocok dengan salah satu label untuk field tersebut """ if not text or not text.strip(): return False if field_name not in self.FIELD_LABELS: return field_name.lower() in text.lower() text_upper = text.upper().strip() # Explicit conflict prevention if field_name == 'agama' and 'ALAMAT' in text_upper: return False if field_name == 'alamat' and 'AGAMA' in text_upper: return False # Coba exact match dulu (lebih cepat) for label in self.FIELD_LABELS[field_name]: if label in text_upper: return True # Fuzzy match jika tidak ada exact match # Ekstrak kata pertama dari text (biasanya label ada di awal) parts = text_upper.split(':')[0].split() if not parts: return False first_word = parts[0] for label in self.FIELD_LABELS[field_name]: label_parts = label.split() if not label_parts: continue # Bandingkan dengan kata pertama ratio = difflib.SequenceMatcher(None, first_word, label_parts[0]).ratio() # Dynamic cutoff logic effective_cutoff = cutoff if len(first_word) < 7: # Use stricter cutoff for short words to prevent ALAMAT (6) matching AGAMA (5) -> ratio 0.73 effective_cutoff = max(cutoff, 0.82) if ratio >= effective_cutoff: if DEBUG_MODE: print(f" [FUZZY LABEL] '{first_word}' matched '{label}' (ratio={ratio:.2f})") return True return False def _extract_after_label(self, text: str, label_pattern: str) -> Optional[str]: """ Extract content after a label (fuzzy/regex match). Handles cases with/without colons. """ if not text: return None # 1. Try Regex Search if pattern provided if label_pattern: # Construct regex: Label + optional spaces/colon + (Group 1: Value) # flags=re.IGNORECASE should be used # We want to find the END of the label match = re.search(f"({label_pattern})[:\\s]*", text, re.IGNORECASE) if match: # Return everything after the match end return text[match.end():].strip() return None def _parse_balinese_name(self, name: str) -> str: """ Parse nama Bali yang digabung OCR dan tambahkan spasi yang tepat. Contoh: "NIGUSTIAYUNYOMANSUWETRI" -> "NI GUSTI AYU NYOMAN SUWETRI" Struktur nama Bali: [Prefix Gender] + [Gelar Kasta] + [Penanda Gender] + [Urutan Lahir] + [Nama Pribadi] PENTING: Hanya proses jika nama benar-benar mengandung komponen Bali! """ if not name: return name name_upper = name.upper().strip() # Jika sudah ada spasi dengan jumlah wajar, kembalikan apa adanya if name_upper.count(' ') >= 2: return name_upper # Cek apakah nama mengandung komponen Bali # Nama harus dimulai dengan NI, I GUSTI, IDA, atau komponen urutan lahir Bali name_clean = name_upper.replace(' ', '') is_balinese_name = False # Cek prefix khas Bali if name_clean.startswith('NI') and len(name_clean) > 3: # NI harus diikuti komponen Bali lain (GUSTI, LUH, WAYAN, dll) after_ni = name_clean[2:] for comp in ['GUSTI', 'LUH', 'WAYAN', 'MADE', 'NYOMAN', 'KETUT', 'PUTU', 'KADEK', 'KOMANG', 'PASEK', 'PANDE']: if after_ni.startswith(comp): is_balinese_name = True break elif name_clean.startswith('IGUSTI') or name_clean.startswith('IDABAGUS') or name_clean.startswith('IDAAYU'): is_balinese_name = True elif any(name_clean.startswith(p) for p in ['GUSTI', 'WAYAN', 'PUTU', 'MADE', 'KADEK', 'NYOMAN', 'KOMANG', 'KETUT']): is_balinese_name = True if not is_balinese_name: # Bukan nama Bali, kembalikan dengan pemisahan spasi standar # Jika ada 1 spasi, kembalikan apa adanya if ' ' in name_upper: return name_upper # Jika tidak ada spasi sama sekali, kembalikan apa adanya (mungkin memang 1 kata) return name_upper # Urutan komponen yang akan dicari (dari yang terpanjang ke terpendek untuk akurasi) components_ordered = sorted(self.BALI_NAME_COMPONENTS, key=len, reverse=True) result_parts = [] remaining = name_clean # Parse prefix gender (NI atau I di awal) if remaining.startswith('NI'): result_parts.append('NI') remaining = remaining[2:] elif remaining.startswith('I') and len(remaining) > 1: # Pastikan bukan bagian dari kata lain next_char = remaining[1] if len(remaining) > 1 else '' # Cek apakah karakter setelah I adalah konsonan (bukan vokal) if next_char not in 'AIUEO': result_parts.append('I') remaining = remaining[1:] # Parse komponen-komponen lainnya found = True max_iterations = 10 # Prevent infinite loop iteration = 0 while remaining and found and iteration < max_iterations: found = False iteration += 1 for component in components_ordered: if remaining.startswith(component): # Skip jika komponen sudah ada di result (kecuali nama pribadi) if component not in result_parts or component not in self.BALI_NAME_COMPONENTS: result_parts.append(component) remaining = remaining[len(component):] found = True break # Sisa adalah nama pribadi if remaining: result_parts.append(remaining) parsed_name = ' '.join(result_parts) # Log jika ada perubahan if parsed_name != name_upper: print(f" [BALI NAME] '{name_upper}' -> '{parsed_name}'") return parsed_name def _search_best_match_in_text(self, text: str, candidates: List[str], prefix: str = "") -> tuple: """ Search if any candidate is present in text using multiple strategies: 1. Exact substring 2. Prefix + Candidate (Fuzzy) - e.g. "PROVINSI BALI" 3. Candidate Only (Fuzzy) - e.g. "BALI" (if prefix is missing/damaged) Returns (best_candidate, confidence_score) """ text_upper = text.upper() best_match = None best_ratio = 0.0 # Strategy 1: Exact substring match (fastest & most reliable) for candidate in candidates: if candidate in text_upper: if len(candidate) > len(best_match or ""): best_match = candidate best_ratio = 1.0 if best_ratio == 1.0: return best_match, best_ratio # Strategy 2: Prefix Construction & Fuzzy Match prefix_upper = prefix.upper() if prefix else "" # DEBUG: Print checking (controlled by DEBUG_MODE) if DEBUG_MODE: print(f"DEBUG Check Text: '{text_upper}' with Prefix: '{prefix_upper}'") for candidate in candidates: # 2a. Compare with Prefix + Space (e.g. "PROVINSI BALI") if prefix: target_spaced = f"{prefix_upper} {candidate}" s_spaced = difflib.SequenceMatcher(None, target_spaced, text_upper) ratio_spaced = s_spaced.ratio() # print(f" -> Compare '{target_spaced}' vs '{text_upper}' = {ratio_spaced:.2f}") if ratio_spaced > best_ratio and ratio_spaced > 0.5: best_ratio = ratio_spaced best_match = candidate # 2b. Compare with Prefix NO SPACE (e.g. "PROVINSIBALI") # This handles "PROVNSIBALI" perfectly target_merged = f"{prefix_upper}{candidate}" s_merged = difflib.SequenceMatcher(None, target_merged, text_upper) ratio_merged = s_merged.ratio() if DEBUG_MODE: print(f" -> Compare Merged '{target_merged}' vs '{text_upper}' = {ratio_merged:.2f}") if ratio_merged > best_ratio and ratio_merged > 0.5: best_ratio = ratio_merged best_match = candidate # 2c. Compare Candidate ONLY (e.g. "BALI") if len(candidate) > 3: s_raw = difflib.SequenceMatcher(None, candidate, text_upper) ratio_raw = s_raw.ratio() # print(f" -> Compare Raw '{candidate}' vs '{text_upper}' = {ratio_raw:.2f}") if ratio_raw > best_ratio and ratio_raw > 0.6: best_ratio = ratio_raw best_match = candidate if DEBUG_MODE: print(f"DEBUG Best Match: {best_match} ({best_ratio:.2f})") return best_match, best_ratio def _detect_image_size(self, ocr_results: List[Dict]) -> tuple: """Detect image dimensions from bounding boxes""" max_x, max_y = 0, 0 for r in ocr_results: bbox = r.get('bbox', []) if bbox and len(bbox) >= 4: for point in bbox: if len(point) >= 2: max_x = max(max_x, point[0]) max_y = max(max_y, point[1]) # Add some margin return (int(max_x * 1.05), int(max_y * 1.05)) if max_x > 0 else (1000, 640) def _extract_by_zones(self, zone_texts: Dict[str, List[str]], result: Dict): """Extract fields based on zone assignments""" # PROVINSI from header if 'header_provinsi' in zone_texts: print(f"DEBUG Zone Provinsi Content: {zone_texts['header_provinsi']}") for text in zone_texts['header_provinsi']: text_clean = text.strip() # Use prefix strategy: "PROVINSI " + result vs text match, score = self._search_best_match_in_text(text_clean, self.PROVINSI_LIST, prefix="PROVINSI") # LOWER THRESHOLD to 0.5 because "PROVINSI BALI" vs "PROVNSIBALI" is roughly 0.5-0.6 range if match and score > 0.5: result['provinsi'] = match # Remove the found province (and label) from text to see what's left # If we matched "PROVINSI JAWA TIMUR", the text might be "PROVNSIJAWATMRKABUPATENSUMENEP" # It's hard to cleanly remove "PROVISI JAWA TIMUR" if it was fuzzy matched. # BUT, we can try to find "KABUPATEN" or "KOTA" in the original text # independent of the province match if 'kabupaten' in text_clean.lower() or 'kota' in text_clean.lower(): parts = re.split(r'(?i)\s*(kabupaten|kota)', text_clean) if len(parts) > 1: kab_part = "".join(parts[1:]).strip() kab_val = re.sub(r'^(?i)(kabupaten|kota)\s*', '', kab_part).strip() if kab_val and result['kabupaten_kota'] is None: prefix = "KABUPATEN" if "kabupaten" in text_clean.lower() else "KOTA" result['kabupaten_kota'] = f"{prefix} {kab_val.upper()}" break # Fallback to keyword splitting (Legacy/Blurry fallback) text_lower = text.lower() val = text # If keyword exists, strip it if 'provinsi' in text_lower: split_prov = re.split(r'(?i)provinsi\s*', text, 1) if len(split_prov) > 1: val = split_prov[1].strip() else: val = "" # Check for merged text if 'kabupaten' in text_lower or 'kota' in text_lower: parts = re.split(r'(?i)\s*(kabupaten|kota)', val) val = parts[0].strip() if len(parts) > 1: kab_part = "".join(parts[1:]).strip() kab_val = re.sub(r'^(?i)(kabupaten|kota)\s*', '', kab_part).strip() if kab_val and result['kabupaten_kota'] is None: prefix = "KABUPATEN" if "kabupaten" in text_lower else "KOTA" result['kabupaten_kota'] = f"{prefix} {kab_val.upper()}" if val and len(val) > 2: # Try fuzzy match again on the cleaned value best_match = self._find_best_match(val.upper(), self.PROVINSI_LIST, cutoff=0.6) if best_match: result['provinsi'] = best_match else: result['provinsi'] = val.upper() break # KABUPATEN/KOTA from header if 'header_kabupaten' in zone_texts: for text in zone_texts['header_kabupaten']: text_lower = text.lower() val = text # Check keyword if 'kabupaten' in text_lower or 'kota' in text_lower: split_kab = re.split(r'(?i)\s*(kabupaten|kota)\s*', text, 1) if len(split_kab) > 1: val = split_kab[-1].strip() else: val = "" # If no keyword, but it's in the kabupaten zone, assume it's data if val: # Re-add prefix standard if we separated it or if it was missing # Heuristic: if validation suggests it's a known regency, we are good. # For now, standardize format. if result['kabupaten_kota'] is None: prefix = "KABUPATEN" if "kabupaten" in text_lower else "KOTA" # If no keyword found, default to KABUPATEN? Or better check Wilayah? # Let's default to detected keyword or KABUPATEN if "kota" in text_lower: prefix = "KOTA" else: prefix = "KABUPATEN" result['kabupaten_kota'] = f"{prefix} {val.upper()}" break # NAMA from nama zone (skip label line) if 'nama' in zone_texts: for text in zone_texts['nama']: text_lower = text.lower() if 'nama' not in text_lower and len(text) > 2: result['nama'] = text.upper() break elif 'nama' in text_lower: val = self._extract_value_from_text(text) if val and 'nama' not in val.lower(): result['nama'] = val.upper() # TTL from ttl zone if 'ttl' in zone_texts: for text in zone_texts['ttl']: # Skip if text is JUST the label (length check or fuzzy match) if len(text) < 15 and self._is_label_match(text, 'tempat_lahir'): continue if 'tempat' in text.lower() or 'lahir' in text.lower() or 'tgl' in text.lower() or len(text) > 5: val = self._extract_value_from_text(text) if val: # Don't accept if val looks like label if self._is_label_match(val, 'tempat_lahir') and len(val) < 20: continue self._parse_ttl(val, result) # Only break if we actually got a birth date, otherwise keep looking if result['tanggal_lahir']: break # JENIS KELAMIN if 'jenis_kelamin' in zone_texts: for text in zone_texts['jenis_kelamin']: text_lower = text.lower() if 'laki' in text_lower: result['jenis_kelamin'] = 'LAKI-LAKI' break elif 'perempuan' in text_lower or 'wanita' in text_lower: result['jenis_kelamin'] = 'PEREMPUAN' break # GOL DARAH if 'gol_darah' in zone_texts: for text in zone_texts['gol_darah']: gol_match = re.search(r'([ABO]{1,2}[+\-]?)', text, re.IGNORECASE) if gol_match: result['gol_darah'] = gol_match.group(1).upper() break # ALAMAT if 'alamat' in zone_texts: for text in zone_texts['alamat']: if 'alamat' not in text.lower() or len(zone_texts['alamat']) == 1: val = self._extract_value_from_text(text) if 'alamat' in text.lower() else text if val and 'alamat' not in val.lower(): result['alamat'] = val.upper() break # RT/RW if 'rt_rw' in zone_texts: for text in zone_texts['rt_rw']: rt_rw_match = re.search(r'(\d{3})\s*/\s*(\d{3})', text) if rt_rw_match: result['rt_rw'] = f"{rt_rw_match.group(1)}/{rt_rw_match.group(2)}" break # KEL/DESA if 'kel_desa' in zone_texts: for text in zone_texts['kel_desa']: if 'kel' in text.lower() or 'desa' in text.lower(): val = self._extract_value_from_text(text) if val and 'kel' not in val.lower(): result['kel_desa'] = val.upper() break elif result['kel_desa'] is None: # Fallback context: simple text result['kel_desa'] = text.upper() # KECAMATAN if 'kecamatan' in zone_texts: for text in zone_texts['kecamatan']: if 'kec' in text.lower(): val = self._extract_value_from_text(text) if val and 'kec' not in val.lower(): result['kecamatan'] = val.upper() break elif result['kecamatan'] is None: result['kecamatan'] = text.upper() # AGAMA if 'agama' in zone_texts: for text in zone_texts['agama']: val = text.upper() if 'agama' in text.lower(): val = self._extract_value_from_text(text).upper() # Verify against valid list for agama in self.AGAMA_LIST: if agama.upper() in val: result['agama'] = agama.upper() break if result['agama']: break # STATUS PERKAWINAN if 'status' in zone_texts: for text in zone_texts['status']: val = text.upper() # Normalize common OCR errors (e.g. BELUMKAWIN) val = val.replace("BELUMKAWIN", "BELUM KAWIN") # Check against official list found_status = False for status in self.STATUS_PERKAWINAN_LIST: if status in val: result['status_perkawinan'] = status found_status = True break if found_status: break # PEKERJAAN if 'pekerjaan' in zone_texts: best_job = None potential_job = None for text in zone_texts['pekerjaan']: val = text.upper() if 'pekerjaan' in text.lower(): val = self._extract_value_from_text(text).upper() # Clean up val = val.strip() if not val or len(val) < 3 or 'PEKERJAAN' in val: continue # 1. Check against wildcard/list (Priority) # Buruh, Karyawan, Pelajar, dll if any(job.upper() in val for job in self.PEKERJAAN_LIST): best_job = val break # Found a definitive job # 2. Save as potential if it's NOT a known bad value (like City names) # Avoid capturing 'TABANAN', 'JAKARTA', date strings if not any(city in val for city in ['KABUPATEN', 'KOTA', 'TABANAN', 'BADUNG', 'DENPASAR', 'JAKARTA', 'BANDUNG']): if not re.search(r'\d{2}-\d{2}-\d{4}', val): # Avoid dates if potential_job is None: potential_job = val if best_job: result['pekerjaan'] = best_job elif potential_job: result['pekerjaan'] = potential_job # WNI if 'wni' in zone_texts: for text in zone_texts['wni']: if 'wni' in text.lower(): result['kewarganegaraan'] = 'WNI' break elif 'wna' in text.lower(): result['kewarganegaraan'] = 'WNA' break # PENERBITAN area (tempat & tanggal dalam satu zona) if 'penerbitan' in zone_texts: for text in zone_texts['penerbitan']: # Look for date date_match = re.search(r'(\d{2}[-/]\d{2}[-/]\d{4})', text) if date_match and result['tanggal_penerbitan'] is None: result['tanggal_penerbitan'] = date_match.group(1) def extract(self, ocr_results: List[Dict]) -> Dict[str, Optional[str]]: """ Ekstrak field KTP dari hasil OCR dengan template-based zone detection Args: ocr_results: List hasil dari OCREngine.extract_text() Returns: Dict dengan field KTP """ result = { 'nik': None, 'nama': None, 'tempat_lahir': None, 'tanggal_lahir': None, 'jenis_kelamin': None, 'gol_darah': None, 'alamat': None, 'rt_rw': None, 'kel_desa': None, 'kecamatan': None, 'agama': None, 'status_perkawinan': None, 'pekerjaan': None, 'kewarganegaraan': None, 'berlaku_hingga': 'SEUMUR HIDUP', # Default sesuai peraturan pemerintah e-KTP 'provinsi': None, 'kabupaten_kota': None, 'tanggal_penerbitan': None, } # Detect image dimensions from bounding boxes img_width, img_height = self._detect_image_size(ocr_results) # Assign zones to each OCR result zone_texts = {} # zone_name -> list of texts for r in ocr_results: x_center = r.get('x_center', 0) y_center = r.get('y_center', 0) zone = self._get_zone(x_center, y_center, img_width, img_height) if zone: if zone not in zone_texts: zone_texts[zone] = [] zone_texts[zone].append(r['text']) # Debug: print zone assignments print("\n[DEBUG KTPExtractor] Zone assignments:") for zone, texts in zone_texts.items(): print(f" {zone}: {texts}") # Extract fields using zone-based approach self._extract_by_zones(zone_texts, result) # Gabungkan semua teks untuk fallback pattern matching texts = [r['text'].strip() for r in ocr_results] all_text = '\n'.join(texts) # Ekstrak NIK (16 digit) - bisa ada di mana saja nik_match = re.search(r'\b(\d{16})\b', all_text) if nik_match: result['nik'] = nik_match.group(1) print(f" -> NIK found: {result['nik']}") # Fallback: Parse line by line for fields not found by zone for i, text in enumerate(texts): # Skip baris yang hanya berisi punctuation atau kosong text_stripped = text.strip() if not text_stripped or text_stripped in [':', '：', '.', '-', '/', '|']: continue # Skip baris yang terlalu pendek (hanya 1-2 karakter non-alfanumerik) if len(text_stripped) <= 2 and not any(c.isalnum() for c in text_stripped): continue text_lower = text.lower() # Normalize colons text_normalized = re.sub(self.COLON_PATTERN, ':', text) text_norm_lower = text_normalized.lower() # ===== PROVINSI ===== if 'provinsi' in text_lower and result['provinsi'] is None: # Split by PROVINSI and take remainder split_prov = re.split(r'(?i)provinsi\s*', text, 1) if len(split_prov) > 1: val = split_prov[1].strip() # Check if it contains kabupaten/kota (merged line case) if 'kabupaten' in val.lower() or 'kota' in val.lower(): parts = re.split(r'(?i)\s*(kabupaten|kota)', val) val = parts[0].strip() if val: # Fuzzy match against valid provinces best_match = self._find_best_match(val.upper(), self.PROVINSI_LIST, cutoff=0.6) if best_match: result['provinsi'] = best_match else: result['provinsi'] = val.upper() # Check for next line if current line only had 'PROVINSI' if result['provinsi'] is None and i + 1 < len(texts): next_text = texts[i+1].strip() next_lower = next_text.lower() # Only take next line if it doesn't look like another field if not any(kw in next_lower for kw in ['provinsi', 'kabupaten', 'kota', 'nik']): # Fuzzy match next line val = next_text.upper() best_match = self._find_best_match(val, self.PROVINSI_LIST, cutoff=0.6) if best_match: result['provinsi'] = best_match else: result['provinsi'] = val # ===== KABUPATEN/KOTA ===== if ('kabupaten' in text_lower or 'kota' in text_lower or 'jakarta' in text_lower) and result['kabupaten_kota'] is None: if 'provinsi' not in text_lower: # Bukan bagian dari provinsi # Split by KABUPATEN or KOTA and take remainder split_kab = re.split(r'(?i)\s*(kabupaten|kota)\s*', text, 1) if len(split_kab) > 1: prefix = "KABUPATEN" if "kabupaten" in text_lower else "KOTA" val = split_kab[-1].strip() if val: result['kabupaten_kota'] = f"{prefix} {val.upper()}" else: result['kabupaten_kota'] = text.strip().upper() else: result['kabupaten_kota'] = text.strip().upper() # ===== NAMA ===== if result['nama'] is None and self._is_label_match(text, 'nama'): val = self._extract_after_label(text_normalized, 'nama') current_name = "" if val: current_name = val.upper() # Loop check baris berikutnya for Name (handle 2-3 lines) offset = 1 # Batasi maksimal 2 baris tambahan untuk Nama (total 3 baris) while i + offset < len(texts) and offset <= 2: next_text = texts[i+offset].strip() next_lower = next_text.lower() is_stop = False # 1. Check Stop Keywords (Field Labels below Name) # Stop if next line is Tempat Lahir, Jenis Kelamin, Alamat, etc. stop_keywords = ['tempat', 'lahir', 'tgl', 'jenis', 'kelamin', 'alamat', 'rt/rw', 'nik'] if any(kw in next_lower for kw in stop_keywords): is_stop = True print(f" [NAMA STOP] Matched stop keyword in '{next_text}'") # 2. Check Case Sensitivity (Heuristic) if not is_stop: letters = [c for c in next_text if c.isalpha()] if letters: upper_count = sum(1 for c in letters if c.isupper()) upper_ratio = upper_count / len(letters) # If mostly lowercase/title case, likely a label (e.g. "Tempat Lahir") if upper_ratio < 0.4 and len(letters) > 3: is_stop = True print(f" [NAMA STOP] Likely Label based on Case (Ratio={upper_ratio:.2f})") if not is_stop: if len(next_text) > 2: print(f" [NAMA MERGE] Merging '{next_text}'") if current_name: current_name += " " + next_text.upper() else: current_name = next_text.upper() offset += 1 else: print(f" [NAMA SKIP] Too short '{next_text}'") # Kalau terlalu pendek (noise), boleh skip atau stop? # Biasanya nama tidak putus jadi 1 huruf. Anggap stop utk aman, atau skip. # Kita skip saja increment offset. offset += 1 else: break if current_name: # Fix Spacing Issues (e.g. BAGUSGEDE -> BAGUS GEDE) current_name = re.sub(r'(BAGUS)(GEDE)', r'\1 \2', current_name) current_name = re.sub(r'(ANAK)(AGUNG)', r'\1 \2', current_name) # Common issue result['nama'] = current_name # ===== TEMPAT/TANGGAL LAHIR ===== # ... (starts around line 830 in original) ... # (Skipping down to ALAMAT section for the replacement block) # ... regex find ... # ===== ALAMAT ===== (dengan fuzzy label matching) if result['alamat'] is None and self._is_label_match(text, 'alamat'): val = self._extract_after_label(text_normalized, r'a{1,2}l{0,2}a?m{0,2}a?t') # Logic multi-line current_addr = "" if val: current_addr = val.upper() # Loop check baris berikutnya (bisa ambil i+1, i+2, dst selama bukan label) offset = 1 while i + offset < len(texts): next_text = texts[i+offset].strip() print(f" [ALAMAT CHECK] Offset +{offset}: '{next_text}'") next_lower = next_text.lower() is_stop = False # 1. Cek Pola RT/RW (angka/angka) -> Pasti STOP if re.search(r'\d{3}\s*/\s*\d{3}', next_text) or re.match(r'^[.\-]+\s*/\s*[.\-]+$', next_text): is_stop = True print(" [ALAMAT STOP] Matched RT/RW pattern") # 2. Cek Keywords Label Pembatas elif any(next_lower.startswith(prefix) for prefix in ['rt/', 'rw', 'rt/rw', 'kel', 'desa', 'kec', 'agama', 'status', 'kawin']): is_stop = True print(" [ALAMAT STOP] Matched label prefix") # 3. Cek Keywords Spesifik Full Word elif any(kw in next_lower for kw in ['kelurahan', 'kecamatan', 'perkawinan', 'kewarganegaraan']): is_stop = True print(" [ALAMAT STOP] Matched distinct label word") # 4. Check Case Sensitivity if not is_stop: letters = [c for c in next_text if c.isalpha()] if letters: upper_count = sum(1 for c in letters if c.isupper()) upper_ratio = upper_count / len(letters) # Jika hampir semua huruf kecil/Title Case (ratio < 0.4), dicurigai sebagai Label # Kecuali kata-kata pendek (< 5 chars) if upper_ratio < 0.4 and len(letters) > 4: is_stop = True print(f" [ALAMAT STOP] Detected Title Case/Lowercase (Ratio={upper_ratio:.2f}) -> Likely Label") # Jika BUKAN pembatas, AMBIL sebagai lanjutan alamat if not is_stop: if len(next_text) > 1: print(f" [ALAMAT MERGE] Merging '{next_text}'") if current_addr: current_addr += " " + next_text.upper() else: current_addr = next_text.upper() offset += 1 # Lanjut cek baris berikutnya else: print(f" [ALAMAT SKIP] Line too short '{next_text}'") offset += 1 # Skip noise, try next line? Or stop? usually skip noise is safer to continue else: print(f" [ALAMAT STOP] Hit Stop Condition '{next_text}'") break # Stop loop if current_addr: result['alamat'] = current_addr if current_addr: result['alamat'] = current_addr # ===== RT/RW ===== # Relaxed pattern to handle -/- or 000/000 if result['rt_rw'] is None: rt_rw_match = re.search(r'(\d{1,3}|-)\s*/\s*(\d{1,3}|-)', text) if rt_rw_match: result['rt_rw'] = f"{rt_rw_match.group(1)}/{rt_rw_match.group(2)}" print(f" [RT/RW] Found {result['rt_rw']}") # ===== KELURAHAN/DESA ===== if ('kel' in text_lower or 'desa' in text_lower) and 'kelamin' not in text_lower: if result['kel_desa'] is None: val = self._extract_after_label(text_normalized, 'kel|desa') if val: result['kel_desa'] = val.upper() elif i + 1 < len(texts): result['kel_desa'] = texts[i+1].strip().upper() # ===== TEMPAT/TANGGAL LAHIR ===== # Gunakan _is_label_match untuk fleksibilitas (e.g. Tempat/Tgl Lahir, Tmpt Lahir) if result['tempat_lahir'] is None and self._is_label_match(text, 'ttl'): print(f" [TTL DEBUG] Matched Label on line {i}: '{text}'") # Regex pattern yang SANGAT fleksibel untuk label TTL # Menangani berbagai variasi: Tmpat/Tgl Lahir, Tempat. Tgl. Lahir, dll # Intinya: T...mp...t L...hir val = self._extract_after_label(text_normalized, r't[ea]m?p?a?t.*?l[a@]hi?r?|tgl.*?l[a@]hi?r?') # Jika val kosong, coba ambil dari baris berikutnya if not val and i + 1 < len(texts): next_text = texts[i+1].strip() next_lower = next_text.lower() stop_keywords = ['jenis', 'kelamin', 'alamat', 'gol', 'darah'] if not any(kw in next_lower for kw in stop_keywords): val = next_text.upper() print(f" [TTL DEBUG] Took next line: '{val}'") if val: print(f" [TTL DEBUG] Parsing value: '{val}'") self._parse_ttl(val, result) if result['tanggal_lahir']: print(f" [TTL DEBUG] Success: {result['tanggal_lahir']}") # ===== JENIS KELAMIN ===== if result['jenis_kelamin'] is None: # 1. Coba cari Label dulu if self._is_label_match(text, 'jenis_kelamin'): val = self._extract_after_label(text_normalized, r'j[ea]ni?s\s*k[ea]l[a@]?mi?n') if val: if 'LAKI' in val.upper(): result['jenis_kelamin'] = 'LAKI-LAKI' elif 'PEREMPUAN' in val.upper() or 'WANITA' in val.upper(): result['jenis_kelamin'] = 'PEREMPUAN' if result['jenis_kelamin'] is None and i + 1 < len(texts): next_text = texts[i+1].upper() if 'LAKI' in next_text: result['jenis_kelamin'] = 'LAKI-LAKI' elif 'PEREMPUAN' in next_text or 'WANITA' in next_text: result['jenis_kelamin'] = 'PEREMPUAN' # 2. Fallback: Cari langsung keyword VALUES if result['jenis_kelamin'] is None: text_upper = text.upper() if 'LAKI-LAKI' in text_upper or 'LAKI - LAKI' in text_upper: result['jenis_kelamin'] = 'LAKI-LAKI' elif 'PEREMPUAN' in text_upper: result['jenis_kelamin'] = 'PEREMPUAN' # ===== GOLONGAN DARAH ===== if result['gol_darah'] is None: # Cek label if self._is_label_match(text, 'gol_darah'): val = self._extract_after_label(text_normalized, r'g?o?l\.?\s*d?a?r?a?h') # Jika label ketemu tapi val kosong, mungkin nempel (Gol.Darah : O) # atau ada di baris ini if val: gd_match = re.search(r'([ABO]{1,2}[+\-]?)', val) if gd_match: result['gol_darah'] = gd_match.group(1).upper() else: # Coba cari pattern gol darah di baris yang sama dengan label gd_match = re.search(r'([ABO]{1,2}[+\-]?)', text.upper().replace('0','O')) if gd_match: result['gol_darah'] = gd_match.group(1).upper() # Cek next line jika baris ini cuma label "Gol Darah" if result['gol_darah'] is None and self._is_label_match(text, 'gol_darah') and i+1 < len(texts): next_text = texts[i+1].strip().upper() if len(next_text) < 5: # Pendek, asumsi gol darah gd_match = re.search(r'([ABO]{1,2}[+\-]?)', next_text) if gd_match: result['gol_darah'] = gd_match.group(1).upper() # ===== KECAMATAN ===== if 'kecamatan' in text_lower or ('kec' in text_lower and 'kelamin' not in text_lower): if result['kecamatan'] is None: val = self._extract_after_label(text_normalized, 'kecamatan|kec') if val: result['kecamatan'] = val.upper() elif i + 1 < len(texts): # Value on next line (real KTP pattern) next_text = texts[i+1].strip() if len(next_text) > 2 and not any(kw in next_text.lower() for kw in ['agama', 'status', 'pekerjaan']): result['kecamatan'] = next_text.upper() # ===== AGAMA ===== (dengan fuzzy label matching) if self._is_label_match(text, 'agama'): val = self._extract_after_label(text_normalized, r'a?g{0,2}a?m{0,2}a') if val and result['agama'] is None: result['agama'] = val.upper() elif result['agama'] is None and i + 1 < len(texts): # Value on next line (real KTP pattern) next_text = texts[i+1].strip().upper() if next_text in ['ISLAM', 'KRISTEN', 'KATOLIK', 'HINDU', 'BUDHA', 'BUDDHA', 'KONGHUCU']: result['agama'] = next_text else: # Check if line contains only agama name for agama in self.AGAMA_LIST: if agama in text_lower and len(text) < 20: if result['agama'] is None: result['agama'] = text.strip().upper() break # ===== STATUS PERKAWINAN ===== if 'kawin' in text_lower: if result['status_perkawinan'] is None: # Check against official list first text_upper = text.upper().replace("BELUMKAWIN", "BELUM KAWIN") for status in self.STATUS_PERKAWINAN_LIST: if status in text_upper: result['status_perkawinan'] = status break # Fallback to extraction if not found in list if result['status_perkawinan'] is None: val = self._extract_after_label(text_normalized, 'status.*kawin|perkawinan') if val: result['status_perkawinan'] = val.upper() # ===== PEKERJAAN ===== if 'pekerjaan' in text_lower: val = self._extract_after_label(text_normalized, 'pekerjaan') if val and result['pekerjaan'] is None: result['pekerjaan'] = val.upper() elif result['pekerjaan'] is None and i + 1 < len(texts): # Value on next line (real KTP pattern) next_text = texts[i+1].strip() if len(next_text) > 2 and 'kewarganegaraan' not in next_text.lower(): result['pekerjaan'] = next_text.upper() else: # Check if line contains pekerjaan keyword for pekerjaan in self.PEKERJAAN_LIST: if pekerjaan in text_lower and len(text) < 30: if result['pekerjaan'] is None: result['pekerjaan'] = text.strip().upper() break # ===== KEWARGANEGARAAN ===== if 'wni' in text_lower: result['kewarganegaraan'] = 'WNI' elif 'wna' in text_lower: result['kewarganegaraan'] = 'WNA' elif 'warga' in text_lower and result['kewarganegaraan'] is None: val = self._extract_after_label(text_normalized, 'kewarganegaraan|warga') if val: result['kewarganegaraan'] = val.upper() # ===== BERLAKU HINGGA ===== if 'berlaku' in text_lower or 'seumur' in text_lower: if result['berlaku_hingga'] is None: if 'seumur' in text_lower or 'hidup' in text_lower: result['berlaku_hingga'] = 'SEUMUR HIDUP' else: val = self._extract_after_label(text_normalized, 'berlaku') if val: result['berlaku_hingga'] = val.upper() # ===== TANGGAL PENERBITAN (biasanya format DD-MM-YYYY di akhir) ===== # Look for date that is NOT tanggal lahir (different date) if result['tanggal_penerbitan'] is None: # 1. Skip if contains Keywords of other date fields # Jangan ambil jika ada kata 'LAHIR', 'TGL', 'BERLAKU', 'SEUMUR', 'HINGGA' line_clean = text.lower() if any(kw in line_clean for kw in ['lahir', 'lahlr', 'tgl', 'tempat', 'berlaku', 'seumur', 'hingga', 'hidup']): pass # Skip else: # Match date format at end of text or standalone date date_match = re.search(r'(\d{2}[-\s/]\d{2}[-\s/]\d{4})$', text.strip()) if date_match: found_date = date_match.group(1).replace(' ', '-') # Make sure it's not the same as tanggal_lahir if result['tanggal_lahir'] != found_date: # Strict Position Check: MUST be in the bottom 30% of lines # (Untuk menghindari salah ambil tanggal lahir yg mungkin gagal diparsing sbg TTL) if i > len(texts) * 0.7: result['tanggal_penerbitan'] = found_date print(f" [TGL TERBIT] Found '{found_date}' at index {i}/{len(texts)}") else: print(f" [TGL TERBIT SKIP] Date '{found_date}' is too high ({i}/{len(texts)})") # ============================================ # AGGRESSIVE SCAN: Cari agama dari semua teks OCR # ============================================ # Indonesia hanya punya 6 agama resmi, mudah dideteksi if result['agama'] is None: # Daftar agama dengan variasi penulisan agama_patterns = { 'ISLAM': ['ISLAM', 'ISLM', 'ISIAM', 'ISLAMI'], 'KRISTEN': ['KRISTEN', 'KRISTEN PROTESTAN', 'PROTESTAN', 'KRISTN'], 'KATOLIK': ['KATOLIK', 'KATHOLIK', 'KATHOLK', 'KATOLIK ROMA', 'KATOLIK.'], 'HINDU': ['HINDU', 'HNDU', 'HINDU DHARMA', 'HINDHU'], 'BUDDHA': ['BUDDHA', 'BUDHA', 'BUDDA', 'BUDDHIS'], 'KONGHUCU': ['KONGHUCU', 'KHONGHUCU', 'KONGHUCHU', 'CONFUCIUS'], } for text in texts: text_upper = text.upper().strip() # Skip jika teks terlalu pendek atau terlalu panjang if len(text_upper) < 4 or len(text_upper) > 30: continue for agama_std, variants in agama_patterns.items(): for variant in variants: if variant in text_upper: result['agama'] = agama_std print(f" [AGAMA SCAN] Found '{variant}' in '{text_upper}' -> {agama_std}") break if result['agama']: break if result['agama']: break # ============================================ # AGGRESSIVE SCAN: Cari golongan darah dari semua teks OCR # ============================================ # Golongan darah hanya 4: A, B, AB, O (dengan/tanpa rhesus +/-) if result['gol_darah'] is None: gol_darah_patterns = ['AB+', 'AB-', 'A+', 'A-', 'B+', 'B-', 'O+', 'O-', 'AB', 'A', 'B', 'O'] for text in texts: text_upper = text.upper().strip() # Hapus punctuation umum text_clean = re.sub(r'[:\.\,\s]+', '', text_upper) # Konversi 0 (nol) menjadi O (huruf) - OCR sering salah baca text_clean = text_clean.replace('0', 'O') # Skip jika teks terlalu panjang (bukan gol darah) if len(text_clean) > 10: continue # Cari match untuk gol darah (dari panjang ke pendek untuk prioritas AB sebelum A/B) for gol in gol_darah_patterns: # Exact match setelah dibersihkan if text_clean == gol: result['gol_darah'] = gol print(f" [GOL DARAH SCAN] Found '{text_upper}' -> {gol}") break # Match dengan prefix GOL if text_clean == f"GOL{gol}" or text_clean == f"GOLDARAH{gol}": result['gol_darah'] = gol print(f" [GOL DARAH SCAN] Found '{text_upper}' -> {gol}") break # Match sebagai single character di akhir teks pendek if len(text_clean) <= 3 and text_clean.endswith(gol): result['gol_darah'] = gol print(f" [GOL DARAH SCAN] Found '{text_upper}' -> {gol}") break if result['gol_darah']: break # ============================================ # AGGRESSIVE SCAN: Cari berlaku hingga dari semua teks OCR # ============================================ if result['berlaku_hingga'] is None: for text in texts: text_upper = text.upper().strip() if 'SEUMUR' in text_upper or 'HIDUP' in text_upper: result['berlaku_hingga'] = 'SEUMUR HIDUP' print(f" [BERLAKU SCAN] Found '{text_upper}' -> SEUMUR HIDUP") break # Post-processing result = self._post_process(result) return result def _extract_after_label(self, text: str, label_pattern: str) -> Optional[str]: """Ekstrak nilai setelah label (supports various separators)""" patterns = [ rf'(?:{label_pattern})\s*:\s*(.+)', # label: value rf'(?:{label_pattern})\s+([A-Z0-9].+)', # label VALUE (uppercase start) ] for pattern in patterns: match = re.search(pattern, text, re.IGNORECASE) if match: value = match.group(1).strip() # Remove trailing colon or label fragment value = re.sub(r'^[:\s]+', '', value) value = re.sub(r'\s*:\s*$', '', value) if value and len(value) > 1: return value return None def _parse_ttl(self, ttl_text: str, result: Dict): """Parse tempat/tanggal lahir dari text""" ttl_text = ttl_text.strip() # Normalize dates where OCR missed dashes: # "05 08 1978" -> "05-08-1978" # "05 08-1978" -> "05-08-1978" # "05-08 1978" -> "05-08-1978" ttl_text = re.sub(r'(\d{2})[\s]+(\d{2})[\s]+(\d{4})', r'\1-\2-\3', ttl_text) ttl_text = re.sub(r'(\d{2})[\s]+(\d{2})[-/](\d{4})', r'\1-\2-\3', ttl_text) ttl_text = re.sub(r'(\d{2})[-/](\d{2})[\s]+(\d{4})', r'\1-\2-\3', ttl_text) # Handle "0508-1978" -> "05-08-1978" (Missing separator between day/month) ttl_text = re.sub(r'(\d{2})(\d{2})[-/](\d{4})', r'\1-\2-\3', ttl_text) # Handle 8-digit date without separator: "05081978" -> "05-08-1978" date_8digit = re.search(r'(\d{8})', ttl_text) if date_8digit: d = date_8digit.group(1) formatted = f"{d[:2]}-{d[2:4]}-{d[4:]}" ttl_text = ttl_text.replace(d, formatted) # Handle merged city+date like "JAKARTA05-08-1978" - add space before digits ttl_text = re.sub(r'([A-Z])(\d{2}[-/])', r'\1 \2', ttl_text, flags=re.IGNORECASE) # Handle merged city+date like "JAKARTA.05-08-1978" -> replace dot with space ttl_text = re.sub(r'([A-Z])\.(\d)', r'\1 \2', ttl_text, flags=re.IGNORECASE) # Format: "TEMPAT, DD-MM-YYYY" atau "TEMPAT DD-MM-YYYY" date_match = re.search(r'(\d{2}[-/]\d{2}[-/]\d{4})', ttl_text) if date_match: result['tanggal_lahir'] = date_match.group(1) # Tempat adalah bagian sebelum tanggal place = ttl_text[:date_match.start()].strip(' ,:-/.') # Clean up label remnants place = re.sub(r'^(tempat|tgl|lahir|：|:)[/\s:：]*', '', place, flags=re.IGNORECASE).strip() if place and len(place) > 2: result['tempat_lahir'] = place.upper() else: # Coba split by comma parts = ttl_text.split(',') if len(parts) >= 2: result['tempat_lahir'] = parts[0].strip().upper() result['tanggal_lahir'] = parts[1].strip() elif len(parts) == 1 and len(ttl_text) > 2: result['tempat_lahir'] = ttl_text.upper() def _post_process(self, result: Dict) -> Dict: """Post-processing hasil ekstraksi""" # Validasi NIK (harus 16 digit) if result['nik'] and not re.match(r'^\d{16}$', result['nik']): cleaned = re.sub(r'\D', '', result['nik']) if len(cleaned) == 16: result['nik'] = cleaned else: result['nik'] = None # Fix format tanggal lahir yang salah # Pattern: DDMM-YYYY (contoh: 1608-1976) -> DD-MM-YYYY (16-08-1976) if result['tanggal_lahir']: tl = result['tanggal_lahir'] # Match DDMM-YYYY format (salah) wrong_format = re.match(r'^(\d{2})(\d{2})-(\d{4})$', tl) if wrong_format: result['tanggal_lahir'] = f"{wrong_format.group(1)}-{wrong_format.group(2)}-{wrong_format.group(3)}" print(f" [DATE FIX] '{tl}' -> '{result['tanggal_lahir']}'") # Match DDMMYYYY format (tanpa separator) no_sep_format = re.match(r'^(\d{2})(\d{2})(\d{4})$', tl) if no_sep_format: result['tanggal_lahir'] = f"{no_sep_format.group(1)}-{no_sep_format.group(2)}-{no_sep_format.group(3)}" print(f" [DATE FIX] '{tl}' -> '{result['tanggal_lahir']}'") # Clean all string values - remove leading colons and extra whitespace for field in result: if result[field] and isinstance(result[field], str): val = result[field] # Remove leading colons (standard and full-width) val = re.sub(r'^[\s:：]+', '', val) # Remove trailing colons val = re.sub(r'[\s:：]+$', '', val) # Remove double spaces val = re.sub(r'\s+', ' ', val) result[field] = val.strip() # Bersihkan label dari values for field in ['nama', 'alamat', 'tempat_lahir', 'kel_desa', 'kecamatan', 'agama', 'pekerjaan']: if result[field]: # Remove common labels yang ter-capture result[field] = re.sub( r'^(NAMA|ALAMAT|TEMPAT|LAHIR|TGL|KEL|DESA|KELURAHAN|KECAMATAN|KEC|AGAMA|PEKERJAAN|STATUS)[\s:：]*', '', result[field], flags=re.IGNORECASE ).strip() # Fix status perkawinan yang masih mengandung label if result['status_perkawinan']: sp = result['status_perkawinan'] sp = re.sub(r'^(STATUS|PERKAWINAN)[\s:：]*', '', sp, flags=re.IGNORECASE).strip() result['status_perkawinan'] = sp # Fix berlaku hingga if result['berlaku_hingga']: bh = result['berlaku_hingga'] bh = re.sub(r'^(BERLAKU|HINGGA)[\s:：]*', '', bh, flags=re.IGNORECASE).strip() if bh.upper() == 'HIDUP' or 'SEUMUR' in bh.upper(): result['berlaku_hingga'] = 'SEUMUR HIDUP' else: result['berlaku_hingga'] = bh else: # Fallback: Sesuai peraturan pemerintah, e-KTP berlaku seumur hidup # Berlaku untuk e-KTP yang diterbitkan sejak 2011 result['berlaku_hingga'] = 'SEUMUR HIDUP' print(" [FALLBACK] berlaku_hingga = SEUMUR HIDUP (peraturan pemerintah)") # ============================================ # Parse nama Bali jika terdeteksi # ============================================ # Deteksi apakah ini KTP Bali berdasarkan: # 1. Provinsi = BALI # 2. NIK dimulai dengan 51 (kode Bali) # 3. Nama mengandung komponen khas Bali (NI, I GUSTI, dll) is_bali = False if result.get('provinsi') and 'BALI' in result['provinsi'].upper(): is_bali = True elif result.get('nik') and result['nik'].startswith('51'): is_bali = True elif result.get('nama'): nama_upper = result['nama'].upper() # Cek apakah nama dimulai dengan prefix Bali if nama_upper.startswith('NI') or nama_upper.startswith('IGUSTI') or \ nama_upper.startswith('IDABAGUS') or nama_upper.startswith('IDAAYU') or \ any(nama_upper.startswith(p) for p in ['GUSTI', 'WAYAN', 'MADE', 'NYOMAN', 'KETUT', 'PUTU', 'KADEK', 'KOMANG']): is_bali = True if is_bali and result.get('nama'): result['nama'] = self._parse_balinese_name(result['nama']) # ============================================ # Validasi dan koreksi Agama # ============================================ if result.get('agama'): agama = result['agama'].upper().strip() # Fuzzy match terhadap daftar agama valid agama_match = None best_ratio = 0 for valid_agama in self.AGAMA_LIST: ratio = difflib.SequenceMatcher(None, agama, valid_agama.upper()).ratio() if ratio > best_ratio and ratio > 0.6: best_ratio = ratio agama_match = valid_agama.upper() if agama_match: if agama_match != agama: print(f" [AGAMA VALIDATE] '{agama}' -> '{agama_match}' (ratio={best_ratio:.2f})") result['agama'] = agama_match # Tidak ada fallback otomatis untuk agama - harus dari OCR # Fix merged kabupaten/kota names (e.g., JAKARTASELATAN -> JAKARTA SELATAN) if result['kabupaten_kota']: kk = result['kabupaten_kota'] # Add space before directional words kk = re.sub(r'(JAKARTA|BANDUNG|SURABAYA|SEMARANG|MEDAN|BEKASI|TANGERANG|DEPOK|BOGOR)(SELATAN|UTARA|BARAT|TIMUR|PUSAT|TENGAH)', r'\1 \2', kk, flags=re.IGNORECASE) # Common merged patterns kk = re.sub(r'(KOTA|KABUPATEN)([A-Z])', r'\1 \2', kk, flags=re.IGNORECASE) result['kabupaten_kota'] = kk.upper() # Fix merged provinsi names if result['provinsi']: prov = result['provinsi'] prov = re.sub(r'(DKI|DI)(JAKARTA|YOGYAKARTA)', r'\1 \2', prov, flags=re.IGNORECASE) prov = re.sub(r'(JAWA|KALIMANTAN|SULAWESI|SUMATERA|NUSA TENGGARA)(BARAT|TIMUR|TENGAH|SELATAN|UTARA)', r'\1 \2', prov, flags=re.IGNORECASE) result['provinsi'] = prov.upper() # Fix merged alamat/address (e.g., JLKECAPIV -> JL KECAPI V) if result['alamat']: alamat = result['alamat'] # Add space after common street prefixes alamat = re.sub(r'^(JL|JLN|JALAN|GG|GANG|NO|BLOK)([A-Z])', r'\1 \2', alamat, flags=re.IGNORECASE) # Add space before Roman numerals at the end (I, II, III, IV, V, VI, VII, VIII, IX, X) alamat = re.sub(r'([A-Z])([IVX]+)$', r'\1 \2', alamat, flags=re.IGNORECASE) # Add space before single digits/numbers at end alamat = re.sub(r'([A-Z])(\d+)$', r'\1 \2', alamat, flags=re.IGNORECASE) # Fix common patterns: "NO123" -> "NO 123", "BLOKA" -> "BLOK A" alamat = re.sub(r'\b(NO|BLOK)(\d+|[A-Z])\b', r'\1 \2', alamat, flags=re.IGNORECASE) result['alamat'] = alamat.upper() # ============================================ # Cross-validation: Tempat Lahir vs Kel/Desa # ============================================ # Pada KTP, tempat lahir sering sama dengan desa/kelurahan # Jika tempat_lahir mirip dengan kel_desa, gunakan yang tervalidasi if result.get('tempat_lahir') and result.get('kel_desa'): tl = result['tempat_lahir'].upper() kd = result['kel_desa'].upper() # Hitung similarity ratio = difflib.SequenceMatcher(None, tl, kd).ratio() if ratio > 0.7: # Tempat lahir mirip dengan kel/desa, gunakan kel/desa yang sudah divalidasi print(f" [CROSS-VALIDATE] Tempat Lahir '{tl}' mirip dengan Kel/Desa '{kd}' (ratio={ratio:.2f})") result['tempat_lahir'] = kd elif ratio > 0.5: # Cukup mirip, log untuk debugging print(f" [CROSS-VALIDATE] Tempat Lahir '{tl}' mungkin sama dengan Kel/Desa '{kd}' (ratio={ratio:.2f})") # Jika tempat_lahir kosong tapi kel_desa ada, mungkin sama # (tidak otomatis mengisi karena bisa beda) return result if __name__ == "__main__": # Test sample_ocr = [ {'text': 'PROVINSI JAWA BARAT'}, {'text': 'KABUPATEN BANDUNG'}, {'text': 'NIK : 3204012345678901'}, {'text': 'Nama : JOHN DOE'}, {'text': 'Tempat/Tgl Lahir : BANDUNG, 01-01-1990'}, {'text': 'Jenis Kelamin : LAKI-LAKI'}, {'text': 'Alamat : JL. MERDEKA NO. 123'}, {'text': 'RT/RW : 001/002'}, {'text': 'Kel/Desa : SUKAMAJU'}, {'text': 'Kecamatan : SUKASARI'}, {'text': 'Agama : ISLAM'}, {'text': 'Status Perkawinan : BELUM KAWIN'}, {'text': 'Pekerjaan : KARYAWAN SWASTA'}, {'text': 'Kewarganegaraan : WNI'}, {'text': 'Berlaku Hingga : SEUMUR HIDUP'}, ] extractor = KTPExtractor() result = extractor.extract(sample_ocr) for key, value in result.items(): print(f"{key}: {value}")