refactor(ml): shared TextRegion/TextDirection types for pipeline engines

koharu-ml/Cargo.toml

@@ -12,7 +12,6 @@ keywords.workspace = true
 publish.workspace = true
 
 [dependencies]
-koharu-core = { workspace = true }
 koharu-runtime = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }

koharu-ml/bin/mit48px-ocr.rs

@@ -1,5 +1,5 @@
 use clap::Parser;
-use koharu_core::TextBlock;
+use koharu_ml::TextRegion;
 use koharu_ml::mit48px_ocr::{Mit48pxBlockPrediction, Mit48pxOcr, Mit48pxPrediction};
 use koharu_runtime::{ComputePolicy, RuntimeManager, default_app_data_root};
 
@@ -54,7 +54,7 @@ async fn main() -> anyhow::Result<()> {
     };
 
     let output = if let Some(blocks_path) = &cli.blocks_json {
-        let blocks: Vec<TextBlock> = serde_json::from_str(&std::fs::read_to_string(blocks_path)?)?;
+        let blocks: Vec<TextRegion> = serde_json::from_str(&std::fs::read_to_string(blocks_path)?)?;
         let predictions = model.inference_text_blocks(&image, &blocks)?;
         for prediction in &predictions {
             println!(

koharu-ml/src/comic_text_bubble_detector/mod.rs

@@ -4,12 +4,11 @@ use std::{collections::BTreeMap, time::Instant};
 
 use anyhow::{Context, Result, bail};
 use image::{DynamicImage, GenericImageView, imageops::FilterType};
-use koharu_core::TextBlock;
 use koharu_runtime::RuntimeManager;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
-use crate::{Device, device, loading};
+use crate::{Device, device, loading, types::TextRegion};
 
 use self::model::{RTDetrV2ForObjectDetection, RTDetrV2Outputs};
 
@@ -134,7 +133,7 @@ pub struct ComicTextBubbleDetection {
     pub image_width: u32,
     pub image_height: u32,
     pub detections: Vec<ComicTextBubbleRegion>,
-    pub text_blocks: Vec<TextBlock>,
+    pub text_blocks: Vec<TextRegion>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -459,7 +458,7 @@ fn post_process_object_detection(
 fn detections_to_text_blocks(
     image_dimensions: (u32, u32),
     detections: &[ComicTextBubbleRegion],
-) -> Vec<TextBlock> {
+) -> Vec<TextRegion> {
     let text_boxes = merge_text_regions(
         detections
             .iter()
@@ -480,7 +479,7 @@ fn detections_to_text_blocks(
             continue;
         }
 
-        let block = TextBlock {
+        let block = TextRegion {
             x: bbox[0],
             y: bbox[1],
             width,

koharu-ml/src/comic_text_detector/mod.rs

@@ -9,11 +9,10 @@ use anyhow::{Context, bail};
 use candle_core::{DType, Device, IndexOp, Tensor};
 use candle_transformers::object_detection::{Bbox, non_maximum_suppression};
 use image::{DynamicImage, GenericImageView, GrayImage};
-use koharu_core::TextBlock;
 use koharu_runtime::RuntimeManager;
 use tracing::instrument;
 
-use crate::{device, loading};
+use crate::{device, loading, types::TextRegion};
 
 pub use postprocess::{
     ComicTextDetection, Quad, crop_text_block_bbox, extract_text_block_regions,
@@ -353,7 +352,7 @@ fn tensor_channel_to_gray_resized(
     ))
 }
 
-fn bboxes_to_text_blocks(mut bboxes: Vec<Bbox<usize>>) -> Vec<TextBlock> {
+fn bboxes_to_text_blocks(mut bboxes: Vec<Bbox<usize>>) -> Vec<TextRegion> {
     bboxes.sort_unstable_by(|a, b| {
         let ay = a.ymin + (a.ymax - a.ymin) * 0.5;
         let by = b.ymin + (b.ymax - b.ymin) * 0.5;
@@ -362,7 +361,7 @@ fn bboxes_to_text_blocks(mut bboxes: Vec<Bbox<usize>>) -> Vec<TextBlock> {
 
     bboxes
         .into_iter()
-        .map(|bbox| TextBlock {
+        .map(|bbox| TextRegion {
             x: bbox.xmin,
             y: bbox.ymin,
             width: bbox.xmax - bbox.xmin,

koharu-ml/src/comic_text_detector/postprocess.rs

@@ -1,3 +1,4 @@
+use crate::types::{TextDirection, TextRegion};
 use image::{
     DynamicImage, GrayImage, Luma, Rgb, RgbImage,
     imageops::{self},
@@ -7,7 +8,6 @@ use imageproc::{
     geometric_transformations::{Interpolation, Projection, warp_into},
     morphology::dilate,
 };
-use koharu_core::{TextBlock, TextDirection};
 
 const FINAL_MASK_DILATE_RADIUS: u8 = 2;
 
@@ -18,14 +18,14 @@ pub struct ComicTextDetection {
     pub shrink_map: GrayImage,
     pub threshold_map: GrayImage,
     pub line_polygons: Vec<Quad>,
-    pub text_blocks: Vec<TextBlock>,
+    pub text_blocks: Vec<TextRegion>,
     pub mask: GrayImage,
 }
 
 pub fn refine_segmentation_mask(
     _image: &DynamicImage,
     pred_mask: &GrayImage,
-    blocks: &[TextBlock],
+    blocks: &[TextRegion],
 ) -> GrayImage {
     let width = pred_mask.width();
     let height = pred_mask.height();
@@ -52,7 +52,7 @@ pub fn refine_segmentation_mask(
     }
 
     // Apply a threshold mask: Pixels are preserved exclusively if their probability
-    // exceeds the core threshold (`super::BINARY_THRESHOLD`) and they reside within a known TextBlock geometry.
+    // exceeds the core threshold (`super::BINARY_THRESHOLD`) and they reside within a known TextRegion geometry.
     let base = GrayImage::from_fn(width, height, |x, y| {
         if in_bounds_mask.get_pixel(x, y)[0] != 0
             && pred_mask.get_pixel(x, y)[0] > super::BINARY_THRESHOLD
@@ -76,12 +76,12 @@ pub fn refine_segmentation_mask(
     })
 }
 
-pub fn crop_text_block_bbox(image: &DynamicImage, block: &TextBlock) -> DynamicImage {
+pub fn crop_text_block_bbox(image: &DynamicImage, block: &TextRegion) -> DynamicImage {
     let [x1, y1, x2, y2] = expanded_text_block_crop_bounds(image.width(), image.height(), block);
     image.crop_imm(x1, y1, x2.saturating_sub(x1), y2.saturating_sub(y1))
 }
 
-pub fn extract_text_block_regions(image: &DynamicImage, block: &TextBlock) -> Vec<DynamicImage> {
+pub fn extract_text_block_regions(image: &DynamicImage, block: &TextRegion) -> Vec<DynamicImage> {
     let Some(line_polygons) = block.line_polygons.as_ref() else {
         return vec![crop_text_block_bbox(image, block)];
     };
@@ -107,7 +107,7 @@ pub fn extract_text_block_regions(image: &DynamicImage, block: &TextBlock) -> Ve
 fn expanded_text_block_crop_bounds(
     image_width: u32,
     image_height: u32,
-    block: &TextBlock,
+    block: &TextRegion,
 ) -> [u32; 4] {
     let should_expand = block.detector.as_deref() == Some("ctd")
         || block
@@ -167,7 +167,7 @@ fn expanded_text_block_crop_bounds(
     [x1, y1, x2, y2]
 }
 
-fn warp_line_region(image: &RgbImage, block: &TextBlock, line: &Quad) -> Option<RgbImage> {
+fn warp_line_region(image: &RgbImage, block: &TextRegion, line: &Quad) -> Option<RgbImage> {
     let expanded = maybe_expand_ctd_line(block, line);
     let clipped = clip_quad(&expanded, image.width() as f32, image.height() as f32);
     let bbox = quad_bbox(&clipped);
@@ -240,7 +240,7 @@ fn warp_line_region(image: &RgbImage, block: &TextBlock, line: &Quad) -> Option<
     }
 }
 
-fn maybe_expand_ctd_line(block: &TextBlock, line: &Quad) -> Quad {
+fn maybe_expand_ctd_line(block: &TextRegion, line: &Quad) -> Quad {
     let should_expand = block.detector.as_deref() == Some("ctd")
         && block.source_direction == Some(TextDirection::Horizontal);
     if !should_expand {
@@ -350,7 +350,7 @@ mod tests {
             }
         });
 
-        let block = TextBlock {
+        let block = TextRegion {
             x: 10.0,
             y: 11.0,
             width: 4.0, // Limits to roughly [10, 11] to [14, 15]
@@ -375,7 +375,7 @@ mod tests {
     #[test]
     fn extract_text_block_regions_falls_back_to_bbox_without_lines() {
         let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(24, 24, Rgb([255, 255, 255])));
-        let block = TextBlock {
+        let block = TextRegion {
             x: 4.0,
             y: 5.0,
             width: 10.0,
@@ -392,7 +392,7 @@ mod tests {
     #[test]
     fn crop_text_block_bbox_expands_ctd_crop() {
         let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(48, 48, Rgb([255, 255, 255])));
-        let block = TextBlock {
+        let block = TextRegion {
             x: 10.0,
             y: 12.0,
             width: 12.0,

koharu-ml/src/font_detector/mod.rs

@@ -31,7 +31,7 @@ koharu_runtime::declare_hf_model_package!(
     order: 141,
 );
 
-pub use koharu_core::{FontPrediction, NamedFontPrediction, TextDirection, TopFont};
+pub use crate::types::{FontPrediction, NamedFontPrediction, TextDirection, TopFont};
 
 pub struct FontDetector {
     model: models::Model,

koharu-ml/src/lama/mod.rs

@@ -1,6 +1,7 @@
 mod fft;
 mod model;
 
+use crate::types::TextRegion;
 use anyhow::{Result, bail};
 use candle_core::{DType, Device, Tensor};
 use image::{
@@ -11,7 +12,6 @@ use imageproc::{
     contours::find_contours, distance_transform::Norm, drawing::draw_polygon_mut, edges::canny,
     filter::gaussian_blur_f32, morphology::dilate, point::Point,
 };
-use koharu_core::TextBlock;
 use koharu_runtime::RuntimeManager;
 use tracing::instrument;
 
@@ -90,7 +90,7 @@ impl Lama {
         &self,
         image: &DynamicImage,
         mask: &DynamicImage,
-        text_blocks: Option<&[TextBlock]>,
+        text_blocks: Option<&[TextRegion]>,
     ) -> Result<DynamicImage> {
         if image.dimensions() != mask.dimensions() {
             bail!(
@@ -132,7 +132,7 @@ impl Lama {
         &self,
         image: &RgbImage,
         mask: &GrayImage,
-        text_blocks: &[TextBlock],
+        text_blocks: &[TextRegion],
     ) -> Result<RgbImage> {
         let (im_w, im_h) = image.dimensions();
         let mut inpainted = image.clone();
@@ -235,7 +235,7 @@ impl Lama {
     }
 }
 
-fn block_xyxy(block: &TextBlock, width: u32, height: u32) -> Option<Xyxy> {
+fn block_xyxy(block: &TextRegion, width: u32, height: u32) -> Option<Xyxy> {
     let x1 = block.x.floor().max(0.0) as u32;
     let y1 = block.y.floor().max(0.0) as u32;
     let x2 = (block.x + block.width).ceil().max(block.x.floor()) as u32;
@@ -570,10 +570,10 @@ mod tests {
         enlarge_window, extract_balloon_mask, try_fill_balloon,
     };
     use crate::inpainting::restore_alpha_channel;
+    use crate::types::TextRegion;
     use image::{GrayImage, Luma, Rgb, RgbImage};
     use imageproc::drawing::draw_hollow_rect_mut;
     use imageproc::rect::Rect;
-    use koharu_core::TextBlock;
 
     const ALPHA_RING_RADIUS: u8 = 7;
 
@@ -688,7 +688,7 @@ mod tests {
 
     #[test]
     fn block_xyxy_rounds_and_clamps_document_coords() {
-        let block = TextBlock {
+        let block = TextRegion {
             x: 10.2,
             y: 20.7,
             width: 15.1,

koharu-ml/src/lib.rs

@@ -14,6 +14,9 @@ pub mod paddleocr_vl;
 pub mod pp_doclayout_v3;
 pub mod probability_map;
 pub mod speech_bubble_segmentation;
+pub mod types;
+
+pub use types::{FontPrediction, NamedFontPrediction, Quad, TextDirection, TextRegion, TopFont};
 
 use anyhow::Result;
 use candle_core::utils::{cuda_is_available, metal_is_available};

koharu-ml/src/mit48px_ocr/mod.rs

@@ -6,14 +6,13 @@ use anyhow::{Context, Result};
 use candle_core::{DType, Device, Tensor};
 use candle_nn::VarBuilder;
 use image::{DynamicImage, RgbImage, imageops::FilterType};
-use koharu_core::TextBlock;
 use koharu_runtime::RuntimeManager;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
 use model::{Mit48pxModel, RawPrediction};
 
-use crate::{comic_text_detector::extract_text_block_regions, device, loading};
+use crate::{comic_text_detector::extract_text_block_regions, device, loading, types::TextRegion};
 
 const OCR_CHUNK_SIZE: usize = 16;
 const HF_REPO: &str = "mayocream/mit48px-ocr";
@@ -139,7 +138,7 @@ impl Mit48pxOcr {
     pub fn inference_text_blocks(
         &self,
         image: &DynamicImage,
-        blocks: &[TextBlock],
+        blocks: &[TextRegion],
     ) -> Result<Vec<Mit48pxBlockPrediction>> {
         let mut regions = Vec::new();
         let mut block_indices = Vec::new();

koharu-ml/src/types.rs

@@ -0,0 +1,79 @@
+//! Self-contained primitive types for ML detection/recognition outputs.
+//!
+//! Detector/OCR/font-prediction modules return these; the app layer
+//! (`koharu-app`) maps them into scene `TextData` / `Op` values.
+
+use serde::{Deserialize, Serialize};
+
+/// Reading axis of a detected text region.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TextDirection {
+    #[default]
+    Horizontal,
+    Vertical,
+}
+
+/// A four-point polygon, ordered clockwise from the top-left.
+pub type Quad = [[f32; 2]; 4];
+
+/// A rectangle-ish detected text region with geometry + detector metadata.
+/// This is what detectors emit; the app layer maps it into a scene `TextData` node.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TextRegion {
+    pub x: f32,
+    pub y: f32,
+    pub width: f32,
+    pub height: f32,
+    pub confidence: f32,
+    pub line_polygons: Option<Vec<Quad>>,
+    pub source_direction: Option<TextDirection>,
+    pub rotation_deg: Option<f32>,
+    pub detected_font_size_px: Option<f32>,
+    pub detector: Option<String>,
+}
+
+/// Font-prediction output from a font-detection model.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FontPrediction {
+    pub top_fonts: Vec<TopFont>,
+    pub named_fonts: Vec<NamedFontPrediction>,
+    pub direction: TextDirection,
+    pub text_color: [u8; 3],
+    pub stroke_color: [u8; 3],
+    pub font_size_px: f32,
+    pub stroke_width_px: f32,
+    pub line_height: f32,
+    pub angle_deg: f32,
+}
+
+impl Default for FontPrediction {
+    fn default() -> Self {
+        Self {
+            top_fonts: Vec::new(),
+            named_fonts: Vec::new(),
+            direction: TextDirection::Horizontal,
+            text_color: [0, 0, 0],
+            stroke_color: [0, 0, 0],
+            font_size_px: 0.0,
+            stroke_width_px: 0.0,
+            line_height: 1.0,
+            angle_deg: 0.0,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NamedFontPrediction {
+    pub index: usize,
+    pub name: String,
+    pub language: Option<String>,
+    pub probability: f32,
+    pub serif: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TopFont {
+    pub index: usize,
+    pub score: f32,
+}

koharu-ml/tests/inpaint.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use image::GenericImageView;
-use koharu_core::TextBlock;
+use koharu_ml::TextRegion;
 use koharu_ml::aot_inpainting::AotInpainting;
 use koharu_ml::lama::Lama;
 
@@ -69,7 +69,7 @@ async fn lama_block_aware_inpainting_returns_same_size() -> anyhow::Result<()> {
 
     assert!(found, "mask fixture should contain a non-empty region");
 
-    let block = TextBlock {
+    let block = TextRegion {
         x: min_x as f32,
         y: min_y as f32,
         width: max_x.saturating_sub(min_x).saturating_add(1) as f32,

koharu-ml/tests/ocr.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
-use koharu_core::{TextBlock, TextDirection};
 use koharu_ml::comic_text_detector::extract_text_block_regions;
 use koharu_ml::paddleocr_vl::{PaddleOcrVl, PaddleOcrVlTask};
+use koharu_ml::{TextDirection, TextRegion};
 
 mod support;
 
@@ -11,7 +11,7 @@ mod support;
 async fn paddleocr_vl_reads_dialog_image_via_default_block_path() -> anyhow::Result<()> {
     let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
     let image = image::open(fixtures.join("1.jpg"))?.crop_imm(66, 26, 270, 48);
-    let block = TextBlock {
+    let block = TextRegion {
         x: 0.0,
         y: 0.0,
         width: image.width() as f32,