Merge pull request #605 from KazumaProject/fix/typo-correction

KazumaProject · web-flow · commit 5fd24174140d · 2025-12-28T23:54:58.000-05:00
フリックキーボードのタイピングミスの修正をキーの位置を考慮して行うように修正
diff --git a/app/build.gradle b/app/build.gradle
@@ -29,8 +29,8 @@ android {
         applicationId "com.kazumaproject.markdownhelperkeyboard"
         minSdk 24
         targetSdk 36
-        versionCode 661
-        versionName "1.4.540"
+        versionCode 662
+        versionName "1.4.541"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngine.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngine.kt
@@ -178,7 +178,7 @@ class EnglishEngine {
         // 2) typo（補正） - enableTypoCorrection のときだけ
         // ============
         if (enableTypoCorrection && typoCorrection.isNotEmpty()) {
-            val typoType = 34.toByte()
+            val typoType = 35.toByte()
             val predictiveSet = predictiveSearchReading.toHashSet()
 
             val maxEdits = maxEditsByLength(lowerInput.length)
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt
@@ -17,7 +17,7 @@ class GraphBuilder {
 
     companion object {
         private const val OMISSION_SCORE_OFFSET = 1900
-        private const val TYPO_SCORE_OFFSET = 1600
+        private const val TYPO_SCORE_OFFSET = 2200
     }
 
     /**
@@ -193,20 +193,20 @@ class GraphBuilder {
             }
 
             // 3.x システム辞書 (Typo Correction Prefix)
-            if (enableTypoCorrectionJapaneseFlick && subStr.length > 1) {
+            if (enableTypoCorrectionJapaneseFlick && subStr.length > 2) {
                 val typoPrefixResults = yomiTrie.commonPrefixSearchWithTypoCorrectionPrefix(
                     str = subStr,
                     succinctBitVector = succinctBitVectorLBSYomi,
-                    maxEdits = 1,
+                    maxResults = 98,
                     maxLen = 12, // ここは調整（予測変換の最大長に合わせる）
                 )
 
                 // 見つかったら辞書ヒット扱いにして未知語フォールバック抑制
                 if (typoPrefixResults.isNotEmpty()) foundInAnyDictionary = true
 
                 for (typo in typoPrefixResults) {
-                    // edits=0 は通常検索と重複しやすいのでスキップ推奨
-                    if (typo.editsUsed == 0) continue
+                    // penaltyUsed==0 は通常検索と重複しやすいのでスキップ推奨
+                    if (typo.penaltyUsed == 0) continue
 
                     val yomiStr = typo.yomi
                     val nodeIndex = yomiTrie.getNodeIndex(yomiStr, succinctBitVectorLBSYomi)
@@ -219,7 +219,7 @@ class GraphBuilder {
                     )
 
                     val endIndex = i + yomiStr.length
-                    val penalty = TYPO_SCORE_OFFSET * typo.editsUsed
+                    val penalty = TYPO_SCORE_OFFSET * typo.penaltyUsed
 
                     listToken
                         .sortedBy { it.wordCost }
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/TypoCorrectionResult.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/TypoCorrectionResult.kt
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt
@@ -11,7 +11,11 @@ import com.kazumaproject.connection_id.deflate
 import com.kazumaproject.connection_id.inflate
 import com.kazumaproject.markdownhelperkeyboard.converter.bitset.SuccinctBitVector
 import com.kazumaproject.markdownhelperkeyboard.converter.graph.OmissionSearchResult
-import com.kazumaproject.markdownhelperkeyboard.converter.graph.TypoCorrectionResult
+import com.kazumaproject.markdownhelperkeyboard.converter.typo_correction.FlickDir
+import com.kazumaproject.markdownhelperkeyboard.converter.typo_correction.KanaFlickLayout
+import com.kazumaproject.markdownhelperkeyboard.converter.typo_correction.TypoCandidate
+import com.kazumaproject.markdownhelperkeyboard.converter.typo_correction.TypoCategory
+import com.kazumaproject.markdownhelperkeyboard.converter.typo_correction.TypoCorrectionResult
 import com.kazumaproject.toBitSet
 import com.kazumaproject.toByteArray
 import com.kazumaproject.toByteArrayFromListChar
@@ -706,32 +710,53 @@ class LOUDSWithTermId {
     fun commonPrefixSearchWithTypoCorrectionPrefix(
         str: String,
         succinctBitVector: SuccinctBitVector,
-        maxEdits: Int = 1,
+        maxPenalty: Int = 2,
         maxLen: Int = 12,
+        maxResults: Int = 64, // 任意: 暴発防止
     ): List<TypoCorrectionResult> {
-        val results = LinkedHashSet<TypoCorrectionResult>()
-        val sb = StringBuilder()
 
-        fun dfs(strIndex: Int, nodeIndex: Int, editsUsed: Int) {
-            // ★ 「途中でも leaf なら採用」(ただし空文字は除外)
-            if (sb.isNotEmpty() && isLeaf[nodeIndex]) {
-                results.add(TypoCorrectionResult(sb.toString(), editsUsed))
+        // 同一yomiの重複を最小penaltyで集約
+        val bestPenaltyByYomi = HashMap<String, Int>(128)
+        val sb = StringBuilder(maxLen)
+
+        fun acceptIfLeaf(nodeIndex: Int, penaltyUsed: Int) {
+            if (sb.isEmpty()) return
+            if (!isLeaf[nodeIndex]) return
+
+            val yomi = sb.toString()
+            val prev = bestPenaltyByYomi[yomi]
+            if (prev == null || penaltyUsed < prev) {
+                bestPenaltyByYomi[yomi] = penaltyUsed
             }
+        }
+
+        fun dfs(strIndex: Int, nodeIndex: Int, penaltyUsed: Int) {
+            if (penaltyUsed > maxPenalty) return
+            if (sb.length > maxLen) return
+            if (bestPenaltyByYomi.size >= maxResults) return
+
+            // ★ prefix検索: 途中でも leaf なら採用
+            acceptIfLeaf(nodeIndex, penaltyUsed)
 
+            // 入力を使い切ったら終了（prefixなのでここで止める）
             if (strIndex >= str.length) return
             if (sb.length >= maxLen) return
 
             val ch = str[strIndex]
-            for (variant in getCharTypeCorrectionVariations(ch)) {
-                val nextEdits = editsUsed + if (variant == ch) 0 else 1
-                if (nextEdits > maxEdits) continue
+
+            // ★ 候補をペナルティ昇順で展開（枝刈り）
+            val candidates: List<TypoCandidate> = getTypoCandidates(ch)
+
+            for (cand in candidates) {
+                val nextPenalty = penaltyUsed + cand.penalty
+                if (nextPenalty > maxPenalty) continue
 
                 var childPos = firstChild(nodeIndex, succinctBitVector)
                 while (childPos >= 0 && LBS[childPos]) {
                     val labelNodeId = succinctBitVector.rank1(childPos)
-                    if (labelNodeId < labels.size && labels[labelNodeId] == variant) {
-                        sb.append(variant)
-                        dfs(strIndex + 1, childPos, nextEdits)
+                    if (labelNodeId < labels.size && labels[labelNodeId] == cand.ch) {
+                        sb.append(cand.ch)
+                        dfs(strIndex + 1, childPos, nextPenalty)
                         sb.setLength(sb.length - 1)
                         break
                     }
@@ -740,8 +765,17 @@ class LOUDSWithTermId {
             }
         }
 
-        dfs(strIndex = 0, nodeIndex = 0, editsUsed = 0)
-        return results.toList()
+        // ルート開始
+        dfs(strIndex = 0, nodeIndex = 0, penaltyUsed = 0)
+
+        // 出力整形: penalty昇順 → 長さ降順（好み）→ 文字列昇順
+        return bestPenaltyByYomi.entries
+            .sortedWith(
+                compareBy<Map.Entry<String, Int>> { it.value }
+                    .thenByDescending { it.key.length }
+                    .thenBy { it.key }
+            )
+            .map { TypoCorrectionResult(it.key, it.value) }
     }
 
     private fun searchRecursiveWithTypoCorrection(
@@ -855,4 +889,39 @@ class LOUDSWithTermId {
         return (listOf(char) + neighbors).distinct()
     }
 
+    private fun getTypoCandidates(ch: Char): List<TypoCandidate> {
+        val key = KanaFlickLayout.keyOf(ch) ?: return listOf(TypoCandidate(ch, TypoCategory.Exact))
+
+        val out = ArrayList<TypoCandidate>(16)
+
+        // 1) Exact
+        out.add(TypoCandidate(ch, TypoCategory.Exact))
+
+        // 2) TapKeyInFlick: 同じgroup内の別dir
+        for (dir in FlickDir.entries) {
+            if (dir == key.dir) continue
+            val v = KanaFlickLayout.charOf(key.group, dir) ?: continue
+            out.add(TypoCandidate(v, TypoCategory.TapKeyInFlick))
+        }
+
+        // 3) DistanceNear/Middle/Far: 同dirのまま別groupへ
+        for (g in KanaFlickLayout.allGroups()) {
+            if (g == key.group) continue
+            val v = KanaFlickLayout.charOf(g, key.dir) ?: continue
+
+            val dist = KanaFlickLayout.manhattan(key.group, g)
+            val cat = when (dist) {
+                1 -> TypoCategory.DistanceNear
+                2 -> TypoCategory.DistanceMiddle
+                else -> TypoCategory.DistanceFar
+            }
+            out.add(TypoCandidate(v, cat))
+        }
+
+        // 重複排除 + penalty昇順（探索枝刈りに効く）
+        return out
+            .distinctBy { it.ch to it.category } // 同じ文字が複数カテゴリに入る設計にしたいならここは要調整
+            .sortedWith(compareBy<TypoCandidate> { it.penalty }.thenBy { it.ch })
+    }
+
 }
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/typo_correction/KanaFlickLayout.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/typo_correction/KanaFlickLayout.kt
@@ -0,0 +1,123 @@
+package com.kazumaproject.markdownhelperkeyboard.converter.typo_correction
+
+enum class KeyGroup { A, KA, SA, TA, NA, HA, MA, YA, RA, WA }
+
+enum class FlickDir { CENTER, LEFT, UP, RIGHT, DOWN } // a,i,u,e,o
+
+data class KeyPos(val x: Int, val y: Int)
+data class KanaKey(val group: KeyGroup, val dir: FlickDir)
+
+
+object KanaFlickLayout {
+
+    // 12キーの代表的な配置
+    private val pos = mapOf(
+        KeyGroup.A to KeyPos(0, 0),
+        KeyGroup.KA to KeyPos(1, 0),
+        KeyGroup.SA to KeyPos(2, 0),
+
+        KeyGroup.TA to KeyPos(0, 1),
+        KeyGroup.NA to KeyPos(1, 1),
+        KeyGroup.HA to KeyPos(2, 1),
+
+        KeyGroup.MA to KeyPos(0, 2),
+        KeyGroup.YA to KeyPos(1, 2),
+        KeyGroup.RA to KeyPos(2, 2),
+
+        KeyGroup.WA to KeyPos(0, 3),
+    )
+
+    // 各キーグループ内の5方向（CENTER/LEFT/UP/RIGHT/DOWN）
+    // ※必要なら拗音/濁点/半濁点は別カテゴリで拡張可能
+    private val table: Map<KeyGroup, Map<FlickDir, Char>> = mapOf(
+        KeyGroup.A to mapOf(
+            FlickDir.CENTER to 'あ',
+            FlickDir.LEFT to 'い',
+            FlickDir.UP to 'う',
+            FlickDir.RIGHT to 'え',
+            FlickDir.DOWN to 'お'
+        ),
+        KeyGroup.KA to mapOf(
+            FlickDir.CENTER to 'か',
+            FlickDir.LEFT to 'き',
+            FlickDir.UP to 'く',
+            FlickDir.RIGHT to 'け',
+            FlickDir.DOWN to 'こ'
+        ),
+        KeyGroup.SA to mapOf(
+            FlickDir.CENTER to 'さ',
+            FlickDir.LEFT to 'し',
+            FlickDir.UP to 'す',
+            FlickDir.RIGHT to 'せ',
+            FlickDir.DOWN to 'そ'
+        ),
+        KeyGroup.TA to mapOf(
+            FlickDir.CENTER to 'た',
+            FlickDir.LEFT to 'ち',
+            FlickDir.UP to 'つ',
+            FlickDir.RIGHT to 'て',
+            FlickDir.DOWN to 'と'
+        ),
+        KeyGroup.NA to mapOf(
+            FlickDir.CENTER to 'な',
+            FlickDir.LEFT to 'に',
+            FlickDir.UP to 'ぬ',
+            FlickDir.RIGHT to 'ね',
+            FlickDir.DOWN to 'の'
+        ),
+        KeyGroup.HA to mapOf(
+            FlickDir.CENTER to 'は',
+            FlickDir.LEFT to 'ひ',
+            FlickDir.UP to 'ふ',
+            FlickDir.RIGHT to 'へ',
+            FlickDir.DOWN to 'ほ'
+        ),
+        KeyGroup.MA to mapOf(
+            FlickDir.CENTER to 'ま',
+            FlickDir.LEFT to 'み',
+            FlickDir.UP to 'む',
+            FlickDir.RIGHT to 'め',
+            FlickDir.DOWN to 'も'
+        ),
+        KeyGroup.YA to mapOf(
+            FlickDir.CENTER to 'や',
+            FlickDir.LEFT to '（',
+            FlickDir.UP to 'ゆ',
+            FlickDir.RIGHT to '）',
+            FlickDir.DOWN to 'よ'
+            // LEFT/RIGHT を実運用の「ゃ/ゅ/ょ」等に合わせたいならここを差し替え
+        ),
+        KeyGroup.RA to mapOf(
+            FlickDir.CENTER to 'ら',
+            FlickDir.LEFT to 'り',
+            FlickDir.UP to 'る',
+            FlickDir.RIGHT to 'れ',
+            FlickDir.DOWN to 'ろ'
+        ),
+        KeyGroup.WA to mapOf(
+            FlickDir.CENTER to 'わ',
+            FlickDir.LEFT to 'を',
+            FlickDir.UP to 'ん',
+            FlickDir.RIGHT to 'ー',
+            FlickDir.DOWN to '〜'
+            // ここもあなたの配列に合わせて調整
+        ),
+    )
+
+    // 逆引き: ひらがな -> (キーグループ,方向)
+    private val reverse: Map<Char, KanaKey> = buildMap {
+        for ((g, m) in table) for ((d, ch) in m) put(ch, KanaKey(g, d))
+    }
+
+    fun keyOf(ch: Char): KanaKey? = reverse[ch]
+    fun charOf(group: KeyGroup, dir: FlickDir): Char? = table[group]?.get(dir)
+    fun posOf(group: KeyGroup): KeyPos? = pos[group]
+
+    fun manhattan(a: KeyGroup, b: KeyGroup): Int {
+        val pa = posOf(a) ?: return Int.MAX_VALUE
+        val pb = posOf(b) ?: return Int.MAX_VALUE
+        return kotlin.math.abs(pa.x - pb.x) + kotlin.math.abs(pa.y - pb.y)
+    }
+
+    fun allGroups(): List<KeyGroup> = pos.keys.toList()
+}
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/typo_correction/TypoCandidate.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/typo_correction/TypoCandidate.kt
@@ -0,0 +1,16 @@
+package com.kazumaproject.markdownhelperkeyboard.converter.typo_correction
+
+enum class TypoCategory(val penalty: Int) {
+    Exact(0),
+    TapKeyInFlick(1),      // 同一キー内で方向ミス（か⇄き⇄く⇄け⇄こ など）
+    DistanceNear(1),       // 近距離キー誤タップ（同方向）
+    DistanceMiddle(2),     // 中距離キー誤タップ（同方向）
+    DistanceFar(7),        // 遠距離キー誤タップ（同方向）
+}
+
+data class TypoCandidate(
+    val ch: Char,
+    val category: TypoCategory,
+) {
+    val penalty: Int get() = category.penalty
+}
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/typo_correction/TypoCorrectionResult.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/typo_correction/TypoCorrectionResult.kt
@@ -0,0 +1,3 @@
+package com.kazumaproject.markdownhelperkeyboard.converter.typo_correction
+
+data class TypoCorrectionResult(val yomi: String, val penaltyUsed: Int)
diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/adapters/SuggestionAdapter.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/adapters/SuggestionAdapter.kt
@@ -513,8 +513,9 @@ class SuggestionAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
             (32).toByte() -> ""
             /** Zenz **/
             (33).toByte() -> "[AI]"
+            (34).toByte() -> "[履歴]"
             /** Typo Correction QWERTY **/
-            (34).toByte() -> "[修正]"
+            (35).toByte() -> "[修正]"
             else -> ""
         }
         holder.itemView.isPressed = position == highlightedPosition

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+package com.kazumaproject.markdownhelperkeyboard.converter.typo_correction`
	`2`	`+`
	`3`	`+data class TypoCorrectionResult(val yomi: String, val penaltyUsed: Int)`