Sync pipeline package (EquiFashionDB_pipeline)

EquiFashionDB_pipeline/config.py

@@ -1,166 +1,187 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Optional
-
-import yaml
-
-
-@dataclass
-class SourceEntry:
-    """One logical source (dataset). May scan multiple folders via `images_dirs`."""
-
-    id: str
-    images_dirs: list[str] = field(default_factory=list)
-    recursive: bool = True
-    extensions: list[str] = field(default_factory=lambda: [".jpg", ".jpeg", ".png", ".webp"])
-
-
-@dataclass
-class DedupConfig:
-    enabled: bool = True
-    hash_size: int = 16
-
-
-@dataclass
-class QualityConfig:
-    enabled: bool = False
-    min_short_side_ratio: float = 0.35
-    min_keypoint_conf: float = 0.2
-
-
-@dataclass
-class TextConfig:
-    seed: int = 42
-    typo_prob: float = 0.03
-    token_dropout_prob: float = 0.12
-    truncate_tail_prob: float = 0.08
-
-
-@dataclass
-class EnrichConfig:
-    fabric_patch: int = 128
-    pose_conf_thresh: float = 0.25
-    workers: int = 0
-    pose_json_dir: Optional[str] = None
-
-
-@dataclass
-class PackageConfig:
-    relative_paths: bool = True
-
-
-@dataclass
-class PipelineConfig:
-    output_root: Path
-    target_size: int = 512
-    sources: list[SourceEntry] = field(default_factory=list)
-    raw_manifest_jsonl: Optional[str] = None
-    dedup: DedupConfig = field(default_factory=DedupConfig)
-    quality: QualityConfig = field(default_factory=QualityConfig)
-    taxonomy: dict[str, Any] = field(default_factory=dict)
-    text: TextConfig = field(default_factory=TextConfig)
-    enrich: EnrichConfig = field(default_factory=EnrichConfig)
-    package: PackageConfig = field(default_factory=PackageConfig)
-
-    @property
-    def work_dir(self) -> Path:
-        return self.output_root / "work"
-
-    @property
-    def images512_dir(self) -> Path:
-        return self.output_root / "images_512"
-
-    @property
-    def sketch_dir(self) -> Path:
-        return self.output_root / "sketch"
-
-    @property
-    def fabric_dir(self) -> Path:
-        return self.output_root / "fabric"
-
-    @property
-    def pose_dir(self) -> Path:
-        return self.output_root / "pose_json"
-
-
-def _collect_image_dirs(s: dict[str, Any]) -> list[str]:
-    """YAML may use `images_dir` (string or list) and/or `images_dirs` (list)."""
-    out: list[str] = []
-    if s.get("images_dirs") is not None:
-        v = s["images_dirs"]
-        if isinstance(v, list):
-            out.extend(str(x).strip() for x in v if str(x).strip())
-        elif isinstance(v, str) and v.strip():
-            out.append(v.strip())
-    v = s.get("images_dir")
-    if v is not None:
-        if isinstance(v, list):
-            out.extend(str(x).strip() for x in v if str(x).strip())
-        elif isinstance(v, str) and v.strip():
-            out.append(v.strip())
-    seen: set[str] = set()
-    uniq: list[str] = []
-    for d in out:
-        if d not in seen:
-            seen.add(d)
-            uniq.append(d)
-    return uniq
-
-
-def _parse_sources(raw: list[dict[str, Any]]) -> list[SourceEntry]:
-    out: list[SourceEntry] = []
-    for s in raw or []:
-        out.append(
-            SourceEntry(
-                id=str(s.get("id", "source")),
-                images_dirs=_collect_image_dirs(s),
-                recursive=bool(s.get("recursive", True)),
-                extensions=list(s.get("extensions", [".jpg", ".jpeg", ".png", ".webp"])),
-            )
-        )
-    return out
-
-
-def load_config(path: Path) -> PipelineConfig:
-    with open(path, encoding="utf-8") as f:
-        raw = yaml.safe_load(f) or {}
-    out_root = Path(raw.get("output_root", "./processed_equifashion")).resolve()
-    ded = raw.get("dedup") or {}
-    qual = raw.get("quality") or {}
-    txt = raw.get("text") or {}
-    enr = raw.get("enrich") or {}
-    pkg = raw.get("package") or {}
-    return PipelineConfig(
-        output_root=out_root,
-        target_size=int(raw.get("target_size", 512)),
-        sources=_parse_sources(raw.get("sources") or []),
-        raw_manifest_jsonl=raw.get("raw_manifest_jsonl"),
-        dedup=DedupConfig(enabled=bool(ded.get("enabled", True)), hash_size=int(ded.get("hash_size", 16))),
-        quality=QualityConfig(
-            enabled=bool(qual.get("enabled", False)),
-            min_short_side_ratio=float(qual.get("min_short_side_ratio", 0.35)),
-            min_keypoint_conf=float(qual.get("min_keypoint_conf", 0.2)),
-        ),
-        taxonomy=dict(raw.get("taxonomy") or {}),
-        text=TextConfig(
-            seed=int(txt.get("seed", 42)),
-            typo_prob=float(txt.get("typo_prob", 0.03)),
-            token_dropout_prob=float(txt.get("token_dropout_prob", 0.12)),
-            truncate_tail_prob=float(txt.get("truncate_tail_prob", 0.08)),
-        ),
-        enrich=EnrichConfig(
-            fabric_patch=int(enr.get("fabric_patch", 128)),
-            pose_conf_thresh=float(enr.get("pose_conf_thresh", 0.25)),
-            workers=int(enr.get("workers", 0)),
-            pose_json_dir=enr.get("pose_json_dir"),
-        ),
-        package=PackageConfig(relative_paths=bool(pkg.get("relative_paths", True))),
-    )
-
-
-def write_default_config(dest: Path) -> None:
-    here = Path(__file__).resolve().parent / "defaults.yaml"
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    dest.write_text(here.read_text(encoding="utf-8"), encoding="utf-8")
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+
+@dataclass
+class SourceEntry:
+    """One logical source (dataset). May scan multiple folders via `images_dirs`."""
+
+    id: str
+    images_dirs: list[str] = field(default_factory=list)
+    recursive: bool = True
+    extensions: list[str] = field(default_factory=lambda: [".jpg", ".jpeg", ".png", ".webp"])
+    split: str = "train"  # train | test
+    captions_file: Optional[str] = None
+    captions_format: str = "none"  # none | equifashion_json_list | deepfashion_json_dict | facad_jsonl
+
+
+@dataclass
+class DedupConfig:
+    enabled: bool = True
+    hash_size: int = 16
+
+
+@dataclass
+class QualityConfig:
+    enabled: bool = False
+    min_short_side_ratio: float = 0.35
+
+
+@dataclass
+class TextConfig:
+    seed: int = 42
+    typo_prob: float = 0.03
+    token_dropout_prob: float = 0.12
+    truncate_tail_prob: float = 0.08
+
+
+@dataclass
+class EnrichConfig:
+    fabric_patch: int = 128
+    workers: int = 0
+
+
+@dataclass
+class PackageConfig:
+    relative_paths: bool = True
+
+
+@dataclass
+class PipelineConfig:
+    output_root: Path
+    target_size: int = 512
+    sources: list[SourceEntry] = field(default_factory=list)
+    raw_manifest_jsonl: Optional[str] = None
+    dedup: DedupConfig = field(default_factory=DedupConfig)
+    quality: QualityConfig = field(default_factory=QualityConfig)
+    taxonomy: dict[str, Any] = field(default_factory=dict)
+    text: TextConfig = field(default_factory=TextConfig)
+    enrich: EnrichConfig = field(default_factory=EnrichConfig)
+    package: PackageConfig = field(default_factory=PackageConfig)
+
+    @property
+    def work_dir(self) -> Path:
+        return self.output_root / "work"
+
+    @property
+    def images512_dir(self) -> Path:
+        return self.output_root / "images_512"
+
+    # EquiFashion_DB-like output layout
+    @property
+    def train_dir(self) -> Path:
+        return self.output_root / "train"
+
+    @property
+    def test_dir(self) -> Path:
+        return self.output_root / "test"
+
+    @property
+    def train_sketch_dir(self) -> Path:
+        return self.output_root / "train_sketch"
+
+    @property
+    def train_fabric_dir(self) -> Path:
+        return self.output_root / "train_fabric"
+
+    @property
+    def test_sketch_dir(self) -> Path:
+        return self.output_root / "test_sketch"
+
+    @property
+    def test_fabric_dir(self) -> Path:
+        return self.output_root / "test_fabric"
+
+    @property
+    def sketch_dir(self) -> Path:
+        return self.output_root / "sketch"
+
+    @property
+    def fabric_dir(self) -> Path:
+        return self.output_root / "fabric"
+
+
+def _collect_image_dirs(s: dict[str, Any]) -> list[str]:
+    """YAML may use `images_dir` (string or list) and/or `images_dirs` (list)."""
+    out: list[str] = []
+    if s.get("images_dirs") is not None:
+        v = s["images_dirs"]
+        if isinstance(v, list):
+            out.extend(str(x).strip() for x in v if str(x).strip())
+        elif isinstance(v, str) and v.strip():
+            out.append(v.strip())
+    v = s.get("images_dir")
+    if v is not None:
+        if isinstance(v, list):
+            out.extend(str(x).strip() for x in v if str(x).strip())
+        elif isinstance(v, str) and v.strip():
+            out.append(v.strip())
+    seen: set[str] = set()
+    uniq: list[str] = []
+    for d in out:
+        if d not in seen:
+            seen.add(d)
+            uniq.append(d)
+    return uniq
+
+
+def _parse_sources(raw: list[dict[str, Any]]) -> list[SourceEntry]:
+    out: list[SourceEntry] = []
+    for s in raw or []:
+        out.append(
+            SourceEntry(
+                id=str(s.get("id", "source")),
+                images_dirs=_collect_image_dirs(s),
+                recursive=bool(s.get("recursive", True)),
+                extensions=list(s.get("extensions", [".jpg", ".jpeg", ".png", ".webp"])),
+                split=str(s.get("split", "train")),
+                captions_file=s.get("captions_file"),
+                captions_format=str(s.get("captions_format", "none")),
+            )
+        )
+    return out
+
+
+def load_config(path: Path) -> PipelineConfig:
+    with open(path, encoding="utf-8") as f:
+        raw = yaml.safe_load(f) or {}
+    out_root = Path(raw.get("output_root", "./processed_equifashion")).resolve()
+    ded = raw.get("dedup") or {}
+    qual = raw.get("quality") or {}
+    txt = raw.get("text") or {}
+    enr = raw.get("enrich") or {}
+    pkg = raw.get("package") or {}
+    return PipelineConfig(
+        output_root=out_root,
+        target_size=int(raw.get("target_size", 512)),
+        sources=_parse_sources(raw.get("sources") or []),
+        raw_manifest_jsonl=raw.get("raw_manifest_jsonl"),
+        dedup=DedupConfig(enabled=bool(ded.get("enabled", True)), hash_size=int(ded.get("hash_size", 16))),
+        quality=QualityConfig(
+            enabled=bool(qual.get("enabled", False)),
+            min_short_side_ratio=float(qual.get("min_short_side_ratio", 0.35)),
+        ),
+        taxonomy=dict(raw.get("taxonomy") or {}),
+        text=TextConfig(
+            seed=int(txt.get("seed", 42)),
+            typo_prob=float(txt.get("typo_prob", 0.03)),
+            token_dropout_prob=float(txt.get("token_dropout_prob", 0.12)),
+            truncate_tail_prob=float(txt.get("truncate_tail_prob", 0.08)),
+        ),
+        enrich=EnrichConfig(
+            fabric_patch=int(enr.get("fabric_patch", 128)),
+            workers=int(enr.get("workers", 0)),
+        ),
+        package=PackageConfig(relative_paths=bool(pkg.get("relative_paths", True))),
+    )
+
+
+def write_default_config(dest: Path) -> None:
+    here = Path(__file__).resolve().parent / "defaults.yaml"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(here.read_text(encoding="utf-8"), encoding="utf-8")

EquiFashionDB_pipeline/defaults.yaml

@@ -1,50 +1,40 @@
-utput_root: ./processed_equifashion
-target_size: 512
-
-# Nhiều nguồn: mỗi phần tử là một dataset (source_id). Mỗi dataset có thể có NHIỀU thư mục ảnh.
-# Cách khai báo (chọn một hoặc kết hợp):
-#   - images_dirs: [ "D:/data/FashionGen/batch1", "D:/data/FashionGen/batch2" ]
-#   - images_dir: "một_thư_mục"
-#   - images_dir: [ "thư_mục_a", "thư_mục_b" ]
-sources:
-  - id: FashionGen
-    images_dirs:
-      - "" # ví dụ: D:/datasets/FashionGen/part_a
-      - "" # ví dụ: D:/datasets/FashionGen/part_b
-    recursive: true
-    extensions: [".jpg", ".jpeg", ".png", ".webp"]
-
-  - id: DeepFashion
-    images_dir: "" # một thư mục (tương đương images_dirs: [một phần tử])
-    recursive: true
-
-# Hoặc chỉ dùng manifest (mỗi dòng JSON) — hợp khi ảnh nằm rải rác nhiều nơi đã ghi trong file:
-# raw_manifest_jsonl: ./my_manifest.jsonl
-# Mỗi dòng: {"id": "...", "image_path": "...", "caption": "...", "category_raw": "...", "source_id": "..."}
-
-dedup:
-  enabled: true
-  hash_size: 16
-
-quality:
-  enabled: false
-  min_short_side_ratio: 0.35
-  min_keypoint_conf: 0.2
-
-taxonomy:
-  map_file: null
-
-text:
-  seed: 42
-  typo_prob: 0.03
-  token_dropout_prob: 0.12
-  truncate_tail_prob: 0.08
-
-enrich:
-  fabric_patch: 128
-  pose_conf_thresh: 0.25
-  workers: 0
-  pose_json_dir: null
-
-package:
-  relative_paths: true
+output_root: ./processed_equifashion
+target_size: 512
+
+
+sources:
+  - id: FashionGen
+    images_dirs:
+      - "" # ví dụ: D:/datasets/FashionGen/part_a
+      - "" # ví dụ: D:/datasets/FashionGen/part_b
+    recursive: true
+    extensions: [".jpg", ".jpeg", ".png", ".webp"]
+
+  - id: DeepFashion
+    images_dir: "" # một thư mục (tương đương images_dirs: [một phần tử])
+    recursive: true
+
+
+dedup:
+  enabled: true
+  hash_size: 16
+
+quality:
+  enabled: false
+  min_short_side_ratio: 0.35
+
+taxonomy:
+  map_file: null
+
+text:
+  seed: 42
+  typo_prob: 0.03
+  token_dropout_prob: 0.12
+  truncate_tail_prob: 0.08
+
+enrich:
+  fabric_patch: 128
+  workers: 0
+
+package:
+  relative_paths: true

EquiFashionDB_pipeline/ingest.py

@@ -1,23 +1,65 @@
-"""Build raw_index.jsonl by scanning configured source directories."""
+"""Build raw_index.jsonl by scanning configured source directories (with captions)."""
 
 from __future__ import annotations
 
-import hashlib
 import json
 from pathlib import Path
+from typing import Dict, Optional
 
 from .config import PipelineConfig, SourceEntry
 
 
-def _stable_id(source_id: str, root_resolved: Path, rel: str) -> str:
-    # Include root so the same rel_path under different folders never collides.
-    key = f"{source_id}|{root_resolved.resolve()}|{rel}"
-    return hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
+def _load_caption_map(entry: SourceEntry) -> Dict[str, str]:
+    """
+    Returns mapping from gt filename (basename) -> caption.
+    """
+    if not entry.captions_file or entry.captions_format == "none":
+        return {}
+    p = Path(entry.captions_file).expanduser().resolve()
+    if not p.is_file():
+        return {}
+
+    fmt = entry.captions_format
+    if fmt == "equifashion_json_list":
+        data = json.loads(p.read_text(encoding="utf-8"))
+        out: Dict[str, str] = {}
+        for r in data or []:
+            gt = str(r.get("gt", "")).strip()
+            cap = str(r.get("caption", "")).strip()
+            if gt:
+                out[Path(gt).name] = cap
+        return out
+
+    if fmt == "deepfashion_json_dict":
+        data = json.loads(p.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            return {Path(k).name: str(v) for k, v in data.items()}
+        return {}
+
+    if fmt == "facad_jsonl":
+        out: Dict[str, str] = {}
+        with open(p, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    r = json.loads(line)
+                except Exception:
+                    continue
+                img = str(r.get("image", "")).strip()
+                txt = str(r.get("text", "")).strip()
+                if img:
+                    out[Path(img).name] = txt
+        return out
+
+    return {}
 
 
 def scan_source(entry: SourceEntry) -> list[dict]:
     rows: list[dict] = []
     exts = {e.lower() for e in entry.extensions}
+    cap_map = _load_caption_map(entry)
     for dir_str in entry.images_dirs:
         root = Path(dir_str).expanduser().resolve()
         if not dir_str.strip() or not root.is_dir():
@@ -29,15 +71,18 @@ def scan_source(entry: SourceEntry) -> list[dict]:
             if p.suffix.lower() not in exts:
                 continue
             rel = str(p.relative_to(root)).replace("\\", "/")
-            sid = _stable_id(entry.id, root, rel)
+            gt = Path(rel).name
+            stem = Path(gt).stem
             rows.append(
                 {
-                    "id": sid,
+                    "id": stem,
                     "source_id": entry.id,
                     "source_root": str(root),
                     "image_path": str(p),
                     "rel_path": rel,
-                    "caption": "",
+                    "gt": gt,
+                    "split": entry.split,
+                    "caption": cap_map.get(gt, ""),
                     "category_raw": "",
                 }
             )

EquiFashionDB_pipeline/package.py

@@ -1,53 +1,46 @@
-"""Write final unified manifest JSON (list of records with modality paths)."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-from .config import PipelineConfig
-
-
-def _rel(cfg: PipelineConfig, p: Path) -> str:
-    if cfg.package.relative_paths:
-        try:
-            return str(p.relative_to(cfg.output_root)).replace("\\", "/")
-        except ValueError:
-            return str(p).replace("\\", "/")
-    return str(p).replace("\\", "/")
-
-
-def build_final_records(rows: list[dict[str, Any]], cfg: PipelineConfig) -> list[dict[str, Any]]:
-    out: list[dict[str, Any]] = []
-    for row in rows:
-        if not row.get("use_in_training", True):
-            continue
-        rid = row["id"]
-        img = cfg.images512_dir / f"{rid}.jpg"
-        sk = cfg.sketch_dir / f"{rid}.png"
-        fb = cfg.fabric_dir / f"{rid}.png"
-        pose = cfg.pose_dir / f"{rid}.json"
-        rec = {
-            "id": rid,
-            "source_id": row.get("source_id", ""),
-            "category": row.get("category_normalized") or row.get("category_raw", ""),
-            "caption_clean": row.get("caption_clean", ""),
-            "caption_noisy": row.get("caption_noisy", ""),
-            "paths": {
-                "image_512": _rel(cfg, img),
-                "sketch": _rel(cfg, sk),
-                "fabric_patch": _rel(cfg, fb),
-                "pose_json": _rel(cfg, pose) if pose.is_file() else None,
-            },
-        }
-        out.append(rec)
-    return out
-
-
-def write_manifest(records: list[dict[str, Any]], cfg: PipelineConfig, name: str = "equifashion_manifest.json") -> Path:
-    path = cfg.output_root / name
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(records, f, ensure_ascii=False, indent=2)
-    return path
+"""Write EquiFashion_DB-like captions JSONs and aligned modality paths."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .config import PipelineConfig
+
+
+def _dump_json_list(path: Path, data: list[dict[str, Any]]) -> None:
+    import json
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def write_equifashion_style_outputs(rows: list[dict[str, Any]], cfg: PipelineConfig) -> dict[str, Path]:
+    """
+    Writes:
+    - train.json / test.json: list of {gt, caption}
+    """
+    train_caps: list[dict[str, Any]] = []
+    test_caps: list[dict[str, Any]] = []
+
+    for row in rows:
+        if not row.get("use_in_training", True):
+            continue
+        split = str(row.get("split") or "train").lower()
+        gt = str(row.get("gt") or Path(str(row.get("image_path", ""))).name)
+        cap = str(row.get("caption") or row.get("caption_raw") or "")
+
+        item = {"gt": gt, "caption": cap}
+        if split == "test":
+            test_caps.append(item)
+        else:
+            train_caps.append(item)
+
+    out = {
+        "train_json": cfg.output_root / "train.json",
+        "test_json": cfg.output_root / "test.json",
+    }
+    _dump_json_list(out["train_json"], train_caps)
+    _dump_json_list(out["test_json"], test_caps)
+    return out

EquiFashionDB_pipeline/runner.py

@@ -1,282 +1,310 @@
-"""Orchestrate pipeline stages (ingest → standardize → dedup → text → enrich → package)."""
-
-from __future__ import annotations
-
-import json
-import os
-from concurrent.futures import ProcessPoolExecutor, as_completed
-from pathlib import Path
-from typing import Any, Optional
-
-import cv2
-from tqdm import tqdm
-
-from . import dedup, ingest, package, pose_unify, quality as quality_mod, sketch_fabric, standardize, taxonomy, text_noise
-from .config import PipelineConfig, load_config
-
-
-def _load_jsonl(path: Path) -> list[dict[str, Any]]:
-    if not path.is_file():
-        return []
-    rows: list[dict[str, Any]] = []
-    with open(path, encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                rows.append(json.loads(line))
-    return rows
-
-
-def _save_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        for r in rows:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-
-
-def _default_workers(cfg: PipelineConfig) -> int:
-    w = cfg.enrich.workers
-    if w and w > 0:
-        return w
-    return max(1, (os.cpu_count() or 4) - 1)
-
-
-def stage_ingest(cfg: PipelineConfig) -> Path:
-    cfg.output_root.mkdir(parents=True, exist_ok=True)
-    out = ingest.run_ingest(cfg)
-    idx = cfg.work_dir / "index.jsonl"
-    if out.is_file():
-        rows = _load_jsonl(out)
-        _save_jsonl(idx, rows)
-    return cfg.work_dir / "index.jsonl"
-
-
-def stage_standardize(cfg: PipelineConfig) -> None:
-    idx_path = cfg.work_dir / "index.jsonl"
-    rows = _load_jsonl(idx_path)
-    if not rows and cfg.raw_manifest_jsonl:
-        rows = _load_jsonl(Path(cfg.raw_manifest_jsonl))
-        _save_jsonl(idx_path, rows)
-    if not rows:
-        raise FileNotFoundError(
-            "No index rows. Run ingest with sources (images_dir / images_dirs) or set raw_manifest_jsonl."
-        )
-
-    cfg.images512_dir.mkdir(parents=True, exist_ok=True)
-    for row in tqdm(rows, desc="standardize"):
-        src = Path(row["image_path"])
-        if not src.is_file():
-            row["standardize_error"] = "missing_source_image"
-            continue
-        bgr = standardize.read_image_bgr(src)
-        if bgr is None:
-            row["standardize_error"] = "read_fail"
-            continue
-        if cfg.quality.enabled:
-            quality_mod.annotate_quality(row, bgr, cfg.quality.min_short_side_ratio)
-            if row.get("quality_ok") is False:
-                row["skip_reason"] = "quality_aspect"
-                continue
-        try:
-            sq = standardize.letterbox_square_bgr(bgr, cfg.target_size)
-        except Exception as e:
-            row["standardize_error"] = str(e)
-            continue
-        rid = str(row["id"])
-        dst = cfg.images512_dir / f"{rid}.jpg"
-        standardize.write_jpg(dst, sq)
-        row["image_512"] = str(dst)
-        row["image_size"] = [cfg.target_size, cfg.target_size]
-
-    for row in rows:
-        ok = True
-        if cfg.quality.enabled:
-            ok = bool(row.get("quality_ok", True))
-        row["use_in_training"] = ok and not row.get("skip_reason")
-
-    _save_jsonl(idx_path, rows)
-
-
-def stage_dedup(cfg: PipelineConfig) -> None:
-    idx_path = cfg.work_dir / "index.jsonl"
-    rows = _load_jsonl(idx_path)
-    if not cfg.dedup.enabled:
-        _save_jsonl(idx_path, rows)
-        return
-    without = [r for r in rows if not r.get("image_512")]
-    for row in without:
-        row.setdefault("dedup_status", "no_image")
-    with_img = [r for r in rows if r.get("image_512")]
-    updated, logs = dedup.cluster_duplicates(with_img, "image_512", cfg.dedup.hash_size)
-    by_id = {r["id"]: r for r in without}
-    for r in updated:
-        by_id[r["id"]] = r
-    merged = list(by_id.values())
-    for r in merged:
-        st = r.get("dedup_status")
-        if st == "duplicate":
-            r["use_in_training"] = False
-        elif st == "canonical":
-            r["use_in_training"] = r.get("use_in_training", True)
-        elif st == "hash_fail":
-            r.setdefault("use_in_training", True)
-    _save_jsonl(idx_path, merged)
-    log_path = cfg.work_dir / "dedup_log.txt"
-    log_path.write_text("\n".join(logs), encoding="utf-8")
-
-
-def stage_taxonomy(cfg: PipelineConfig) -> None:
-    idx_path = cfg.work_dir / "index.jsonl"
-    rows = _load_jsonl(idx_path)
-    map_path = cfg.taxonomy.get("map_file") if cfg.taxonomy else None
-    mp = taxonomy.load_taxonomy_map(Path(map_path) if map_path else None)
-    for row in rows:
-        raw = row.get("category_raw") or ""
-        row["category_normalized"] = taxonomy.normalize_category(str(raw), mp)
-    _save_jsonl(idx_path, rows)
-
-
-def stage_text(cfg: PipelineConfig) -> None:
-    idx_path = cfg.work_dir / "index.jsonl"
-    rows = _load_jsonl(idx_path)
-    tc = cfg.text
-    for row in rows:
-        cap = row.get("caption") or row.get("caption_raw") or ""
-        clean = text_noise.clean_caption(str(cap))
-        row["caption_clean"] = clean
-        row["caption_noisy"] = text_noise.noisy_caption(
-            clean,
-            seed=tc.seed + hash(str(row["id"])) % (2**20),
-            typo_prob=tc.typo_prob,
-            token_dropout_prob=tc.token_dropout_prob,
-            truncate_tail_prob=tc.truncate_tail_prob,
-        )
-    _save_jsonl(idx_path, rows)
-
-
-def _enrich_job(args: tuple) -> tuple[str, Optional[str]]:
-    row, cfg_dict = args
-    cfg = cfg_dict  # type: ignore
-    from pathlib import Path as P
-
-    rid = str(row["id"])
-    img_path = P(row["image_512"])
-    pose_dir = cfg.get("pose_json_dir")
-    pose_json = P(pose_dir) / f"{rid}.json" if pose_dir else None
-    if pose_json is not None and not pose_json.is_file():
-        pose_json = None
-    out_sk = P(cfg["sketch_dir"])
-    out_fb = P(cfg["fabric_dir"])
-    out_pose = P(cfg["pose_dir"])
-    stem = rid
-    err: Optional[str] = None
-    bgr = cv2.imread(str(img_path), cv2.IMREAD_COLOR)
-    if bgr is None:
-        return rid, "read_fail"
-    h, w = bgr.shape[:2]
-    pose_unify.copy_or_unify_pose(pose_json, out_pose / f"{stem}.json", (h, w))
-    _, err = sketch_fabric.process_one_sample(
-        img_path,
-        out_sk,
-        out_fb,
-        stem,
-        pose_json,
-        float(cfg["pose_conf_thresh"]),
-        int(cfg["fabric_patch"]),
-    )
-    return stem, err
-
-
-def stage_enrich(cfg: PipelineConfig) -> None:
-    idx_path = cfg.work_dir / "index.jsonl"
-    rows = _load_jsonl(idx_path)
-    rows = [r for r in rows if r.get("use_in_training", True) and r.get("image_512")]
-    cfg.pose_dir.mkdir(parents=True, exist_ok=True)
-    cfg.sketch_dir.mkdir(parents=True, exist_ok=True)
-    cfg.fabric_dir.mkdir(parents=True, exist_ok=True)
-
-    pose_json_dir = cfg.enrich.pose_json_dir
-    cfg_dict: dict[str, Any] = {
-        "pose_json_dir": pose_json_dir,
-        "sketch_dir": str(cfg.sketch_dir),
-        "fabric_dir": str(cfg.fabric_dir),
-        "pose_dir": str(cfg.pose_dir),
-        "pose_conf_thresh": cfg.enrich.pose_conf_thresh,
-        "fabric_patch": cfg.enrich.fabric_patch,
-    }
-    jobs = [(r, cfg_dict) for r in rows]
-    errs: list[tuple[str, str]] = []
-    n_workers = _default_workers(cfg)
-    if n_workers <= 1:
-        for job in tqdm(jobs, desc="enrich"):
-            rid, err = _enrich_job(job)
-            if err:
-                errs.append((rid, err))
-    else:
-        with ProcessPoolExecutor(max_workers=n_workers) as ex:
-            futs = [ex.submit(_enrich_job, job) for job in jobs]
-            for fut in tqdm(as_completed(futs), total=len(futs), desc="enrich"):
-                rid, err = fut.result()
-                if err:
-                    errs.append((rid, err))
-
-    if errs:
-        p = cfg.work_dir / "enrich_errors.txt"
-        p.write_text("\n".join(f"{a}\t{b}" for a, b in errs), encoding="utf-8")
-
-
-def stage_package(cfg: PipelineConfig) -> Path:
-    idx_path = cfg.work_dir / "index.jsonl"
-    rows = _load_jsonl(idx_path)
-    recs = package.build_final_records(rows, cfg)
-    return package.write_manifest(recs, cfg)
-
-
-def run_stages(cfg: PipelineConfig, stages: list[str]) -> None:
-    order = ["ingest", "standardize", "dedup", "taxonomy", "text", "enrich", "package"]
-    want = set(stages)
-    if "all" in want:
-        want = set(order)
-    for name in order:
-        if name not in want:
-            continue
-        if name == "ingest":
-            stage_ingest(cfg)
-        elif name == "standardize":
-            stage_standardize(cfg)
-        elif name == "dedup":
-            stage_dedup(cfg)
-        elif name == "taxonomy":
-            stage_taxonomy(cfg)
-        elif name == "text":
-            stage_text(cfg)
-        elif name == "enrich":
-            stage_enrich(cfg)
-        elif name == "package":
-            out = stage_package(cfg)
-            print(f"Wrote manifest: {out}")
-
-
-def main_cli() -> None:
-    import argparse
-
-    ap = argparse.ArgumentParser(description="EquiFashion-style data pipeline")
-    ap.add_argument("--config", type=Path, default=Path("pipeline_config.yaml"))
-    ap.add_argument(
-        "--stage",
-        default="all",
-        help="Comma-separated: ingest,standardize,dedup,taxonomy,text,enrich,package,all",
-    )
-    ap.add_argument("--init-config", action="store_true", help="Write defaults to --config and exit")
-    args = ap.parse_args()
-
-    if args.init_config:
-        from .config import write_default_config
-
-        write_default_config(args.config.resolve())
-        print(f"Wrote {args.config}")
-        return
-
-    cfg = load_config(args.config.resolve())
-    stages = [s.strip() for s in args.stage.split(",") if s.strip()]
-    run_stages(cfg, stages)
+"""Orchestrate pipeline stages (ingest → standardize → dedup → text → enrich → package)."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Optional
+
+import cv2
+from tqdm import tqdm
+
+from . import dedup, ingest, package, quality as quality_mod, sketch_fabric, standardize, taxonomy, text_noise
+from .config import PipelineConfig, load_config
+
+
+def _load_jsonl(path: Path) -> list[dict[str, Any]]:
+    if not path.is_file():
+        return []
+    rows: list[dict[str, Any]] = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows
+
+
+def _save_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+
+def _default_workers(cfg: PipelineConfig) -> int:
+    w = cfg.enrich.workers
+    if w and w > 0:
+        return w
+    return max(1, (os.cpu_count() or 4) - 1)
+
+
+def stage_ingest(cfg: PipelineConfig) -> Path:
+    cfg.output_root.mkdir(parents=True, exist_ok=True)
+    out = ingest.run_ingest(cfg)
+    idx = cfg.work_dir / "index.jsonl"
+    if out.is_file():
+        rows = _load_jsonl(out)
+        _save_jsonl(idx, rows)
+    return cfg.work_dir / "index.jsonl"
+
+
+def stage_standardize(cfg: PipelineConfig) -> None:
+    idx_path = cfg.work_dir / "index.jsonl"
+    rows = _load_jsonl(idx_path)
+    if not rows and cfg.raw_manifest_jsonl:
+        rows = _load_jsonl(Path(cfg.raw_manifest_jsonl))
+        _save_jsonl(idx_path, rows)
+    if not rows:
+        raise FileNotFoundError(
+            "No index rows. In pipeline_config.yaml, set non-empty paths under `sources` "
+            "(`images_dir` / `images_dirs` pointing to folders that contain images), "
+            "or set `raw_manifest_jsonl` to a JSONL manifest. "
+            "The default template uses empty placeholders — you must replace them with real paths."
+        )
+
+    cfg.train_dir.mkdir(parents=True, exist_ok=True)
+    cfg.test_dir.mkdir(parents=True, exist_ok=True)
+    for row in tqdm(rows, desc="standardize"):
+        src = Path(row["image_path"])
+        if not src.is_file():
+            row["standardize_error"] = "missing_source_image"
+            continue
+        bgr = None
+        if cfg.target_size > 0 or cfg.quality.enabled:
+            bgr = standardize.read_image_bgr(src)
+            if bgr is None:
+                row["standardize_error"] = "read_fail"
+                continue
+        if cfg.quality.enabled:
+            assert bgr is not None
+            quality_mod.annotate_quality(row, bgr, cfg.quality.min_short_side_ratio)
+            if row.get("quality_ok") is False:
+                row["skip_reason"] = "quality_aspect"
+                continue
+        split = str(row.get("split") or "train").lower()
+        gt = str(row.get("gt") or Path(row["image_path"]).name)
+        dst_root = cfg.test_dir if split == "test" else cfg.train_dir
+        # Keep original filename; if collision, rename and update `gt` accordingly.
+        dst = dst_root / gt
+        if dst.exists():
+            stem = Path(gt).stem
+            ext = Path(gt).suffix
+            src_tag = str(row.get("source_id") or "src")
+            k = 1
+            while True:
+                cand = dst_root / f"{stem}__{src_tag}__{k}{ext}"
+                if not cand.exists():
+                    dst = cand
+                    row["gt"] = dst.name
+                    row["id"] = dst.stem
+                    break
+                k += 1
+        if cfg.target_size <= 0:
+            # No resize: byte-copy original file.
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
+            # Record size if possible (best-effort).
+            bgr2 = cv2.imread(str(dst), cv2.IMREAD_COLOR)
+            if bgr2 is not None:
+                h2, w2 = bgr2.shape[:2]
+                row["image_size"] = [int(w2), int(h2)]
+        else:
+            assert bgr is not None
+            try:
+                sq = standardize.letterbox_square_bgr(bgr, cfg.target_size)
+            except Exception as e:
+                row["standardize_error"] = str(e)
+                continue
+            standardize.write_image(dst, sq)
+            row["image_size"] = [cfg.target_size, cfg.target_size]
+        row["image_512"] = str(dst)
+
+    for row in rows:
+        ok = True
+        if cfg.quality.enabled:
+            ok = bool(row.get("quality_ok", True))
+        row["use_in_training"] = ok and not row.get("skip_reason")
+
+    _save_jsonl(idx_path, rows)
+
+
+def stage_dedup(cfg: PipelineConfig) -> None:
+    idx_path = cfg.work_dir / "index.jsonl"
+    rows = _load_jsonl(idx_path)
+    if not cfg.dedup.enabled:
+        _save_jsonl(idx_path, rows)
+        return
+    without = [r for r in rows if not r.get("image_512")]
+    for row in without:
+        row.setdefault("dedup_status", "no_image")
+    with_img = [r for r in rows if r.get("image_512")]
+    updated, logs = dedup.cluster_duplicates(with_img, "image_512", cfg.dedup.hash_size)
+    by_id = {r["id"]: r for r in without}
+    for r in updated:
+        by_id[r["id"]] = r
+    merged = list(by_id.values())
+    for r in merged:
+        st = r.get("dedup_status")
+        if st == "duplicate":
+            r["use_in_training"] = False
+        elif st == "canonical":
+            r["use_in_training"] = r.get("use_in_training", True)
+        elif st == "hash_fail":
+            r.setdefault("use_in_training", True)
+    _save_jsonl(idx_path, merged)
+    log_path = cfg.work_dir / "dedup_log.txt"
+    log_path.write_text("\n".join(logs), encoding="utf-8")
+
+
+def stage_taxonomy(cfg: PipelineConfig) -> None:
+    idx_path = cfg.work_dir / "index.jsonl"
+    rows = _load_jsonl(idx_path)
+    map_path = cfg.taxonomy.get("map_file") if cfg.taxonomy else None
+    mp = taxonomy.load_taxonomy_map(Path(map_path) if map_path else None)
+    for row in rows:
+        raw = row.get("category_raw") or ""
+        row["category_normalized"] = taxonomy.normalize_category(str(raw), mp)
+    _save_jsonl(idx_path, rows)
+
+
+def stage_text(cfg: PipelineConfig) -> None:
+    idx_path = cfg.work_dir / "index.jsonl"
+    rows = _load_jsonl(idx_path)
+    tc = cfg.text
+    for row in rows:
+        cap = row.get("caption") or row.get("caption_raw") or ""
+        clean = text_noise.clean_caption(str(cap))
+        row["caption_clean"] = clean
+        row["caption_noisy"] = text_noise.noisy_caption(
+            clean,
+            seed=tc.seed + hash(str(row["id"])) % (2**20),
+            typo_prob=tc.typo_prob,
+            token_dropout_prob=tc.token_dropout_prob,
+            truncate_tail_prob=tc.truncate_tail_prob,
+        )
+    _save_jsonl(idx_path, rows)
+
+
+def _enrich_job(args: tuple) -> tuple[str, Optional[str]]:
+    row, cfg_dict = args
+    cfg = cfg_dict  # type: ignore
+    from pathlib import Path as P
+
+    rid = str(row["id"])
+    img_path = P(row["image_512"])
+    split = str(row.get("split") or "train").lower()
+    out_sk = P(cfg["train_sketch_dir"] if split == "train" else cfg["test_sketch_dir"])
+    out_fb = P(cfg["train_fabric_dir"] if split == "train" else cfg["test_fabric_dir"])
+    stem = str(Path(str(row.get("gt") or rid)).stem)
+    err: Optional[str] = None
+    bgr = cv2.imread(str(img_path), cv2.IMREAD_COLOR)
+    if bgr is None:
+        return rid, "read_fail"
+    _, err = sketch_fabric.process_one_sample(
+        img_path,
+        out_sk,
+        out_fb,
+        stem,
+        int(cfg["fabric_patch"]),
+    )
+    return stem, err
+
+
+def stage_enrich(cfg: PipelineConfig) -> None:
+    idx_path = cfg.work_dir / "index.jsonl"
+    rows = _load_jsonl(idx_path)
+    # Only enrich TRAIN split. We intentionally do not create test_* modalities.
+    rows = [
+        r
+        for r in rows
+        if r.get("use_in_training", True)
+        and r.get("image_512")
+        and str(r.get("split") or "train").lower() == "train"
+    ]
+    cfg.train_sketch_dir.mkdir(parents=True, exist_ok=True)
+    cfg.train_fabric_dir.mkdir(parents=True, exist_ok=True)
+    cfg_dict: dict[str, Any] = {
+        "train_sketch_dir": str(cfg.train_sketch_dir),
+        "train_fabric_dir": str(cfg.train_fabric_dir),
+        "fabric_patch": cfg.enrich.fabric_patch,
+    }
+    jobs = [(r, cfg_dict) for r in rows]
+    errs: list[tuple[str, str]] = []
+    n_workers = _default_workers(cfg)
+    if n_workers <= 1:
+        for job in tqdm(jobs, desc="enrich"):
+            rid, err = _enrich_job(job)
+            if err:
+                errs.append((rid, err))
+    else:
+        with ProcessPoolExecutor(max_workers=n_workers) as ex:
+            futs = [ex.submit(_enrich_job, job) for job in jobs]
+            for fut in tqdm(as_completed(futs), total=len(futs), desc="enrich"):
+                rid, err = fut.result()
+                if err:
+                    errs.append((rid, err))
+
+    if errs:
+        p = cfg.work_dir / "enrich_errors.txt"
+        p.write_text("\n".join(f"{a}\t{b}" for a, b in errs), encoding="utf-8")
+
+
+def stage_package(cfg: PipelineConfig) -> Path:
+    idx_path = cfg.work_dir / "index.jsonl"
+    rows = _load_jsonl(idx_path)
+    outs = package.write_equifashion_style_outputs(rows, cfg)
+    return outs["train_json"]
+
+
+def run_stages(cfg: PipelineConfig, stages: list[str]) -> None:
+    order = ["ingest", "standardize", "dedup", "taxonomy", "text", "enrich", "package"]
+    want = set(stages)
+    if "all" in want:
+        want = set(order)
+    for name in order:
+        if name not in want:
+            continue
+        if name == "ingest":
+            stage_ingest(cfg)
+        elif name == "standardize":
+            stage_standardize(cfg)
+        elif name == "dedup":
+            stage_dedup(cfg)
+        elif name == "taxonomy":
+            stage_taxonomy(cfg)
+        elif name == "text":
+            stage_text(cfg)
+        elif name == "enrich":
+            stage_enrich(cfg)
+        elif name == "package":
+            out = stage_package(cfg)
+            print(f"Wrote manifest: {out}")
+
+
+def main_cli() -> None:
+    import argparse
+
+    ap = argparse.ArgumentParser(description="EquiFashion-style data pipeline")
+    ap.add_argument("--config", type=Path, default=Path("pipeline_config.yaml"))
+    ap.add_argument(
+        "--stage",
+        default="all",
+        help="Comma-separated: ingest,standardize,dedup,taxonomy,text,enrich,package,all",
+    )
+    ap.add_argument("--init-config", action="store_true", help="Write defaults to --config and exit")
+    args = ap.parse_args()
+
+    if args.init_config:
+        from .config import write_default_config
+
+        write_default_config(args.config.resolve())
+        print(f"Wrote {args.config}")
+        return
+
+    cfg = load_config(args.config.resolve())
+    stages = [s.strip() for s in args.stage.split(",") if s.strip()]
+    run_stages(cfg, stages)

EquiFashionDB_pipeline/sketch_fabric.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import json
 from pathlib import Path
 from typing import Optional, Tuple
 
@@ -10,75 +9,9 @@ import cv2
 import numpy as np
 
 
-def load_pose_candidates(pose_path: Path) -> Optional[np.ndarray]:
-    if not pose_path.is_file():
-        return None
-    with open(pose_path, encoding="utf-8") as f:
-        data = json.load(f)
-    cand = data.get("candidate")
-    if not cand:
-        return None
-    arr = np.asarray(cand, dtype=np.float64)
-    if arr.ndim != 2 or arr.shape[1] < 4:
-        return None
-    return arr
-
-
-def pose_mask_from_candidates(
-    candidates: np.ndarray,
-    hw: Tuple[int, int],
-    conf_thresh: float = 0.25,
-    dilate_px: int = 24,
-) -> np.ndarray:
+def full_image_mask(hw: Tuple[int, int]) -> np.ndarray:
     h, w = hw
-    mask = np.zeros((h, w), dtype=np.uint8)
-    pts = []
-    for row in candidates:
-        x, y, conf = float(row[0]), float(row[1]), float(row[2])
-        if conf < conf_thresh:
-            continue
-        xi = int(round(np.clip(x, 0, w - 1)))
-        yi = int(round(np.clip(y, 0, h - 1)))
-        pts.append([xi, yi])
-    pts = np.asarray(pts, dtype=np.int32)
-    if len(pts) >= 3:
-        hull = cv2.convexHull(pts)
-        cv2.fillConvexPoly(mask, hull, 255)
-    elif len(pts) == 2:
-        cv2.line(mask, tuple(pts[0]), tuple(pts[1]), 255, thickness=max(dilate_px, 8))
-    elif len(pts) == 1:
-        cv2.circle(mask, tuple(pts[0]), dilate_px * 2, 255, thickness=-1)
-    else:
-        return fallback_center_mask(hw)
-
-    if dilate_px > 0:
-        k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (dilate_px * 2 + 1, dilate_px * 2 + 1))
-        mask = cv2.dilate(mask, k, iterations=1)
-    return mask
-
-
-def fallback_center_mask(hw: Tuple[int, int], margin: float = 0.08) -> np.ndarray:
-    h, w = hw
-    mask = np.zeros((h, w), dtype=np.uint8)
-    x0 = int(w * margin)
-    y0 = int(h * margin)
-    x1 = int(w * (1 - margin))
-    y1 = int(h * (1 - margin))
-    mask[y0:y1, x0:x1] = 255
-    return mask
-
-
-def build_garment_mask(
-    pose_json: Optional[Path],
-    hw: Tuple[int, int],
-    conf_thresh: float,
-) -> np.ndarray:
-    if pose_json is None:
-        return fallback_center_mask(hw)
-    cand = load_pose_candidates(pose_json)
-    if cand is None:
-        return fallback_center_mask(hw)
-    return pose_mask_from_candidates(cand, hw, conf_thresh=conf_thresh)
+    return np.full((h, w), 255, dtype=np.uint8)
 
 
 def sketch_canny_masked(
@@ -148,15 +81,13 @@ def process_one_sample(
     out_sketch: Path,
     out_fabric: Path,
     stem: str,
-    pose_json: Optional[Path],
-    conf_thresh: float,
     fabric_patch: int,
 ) -> Tuple[str, Optional[str]]:
     bgr = cv2.imread(str(image_path), cv2.IMREAD_COLOR)
     if bgr is None:
         return stem, f"failed read: {image_path}"
     h, w = bgr.shape[:2]
-    mask = build_garment_mask(pose_json, (h, w), conf_thresh=conf_thresh)
+    mask = full_image_mask((h, w))
     sketch = sketch_canny_masked(bgr, mask)
     fabric = best_texture_patch(bgr, mask, patch_size=fabric_patch)
     out_sketch.mkdir(parents=True, exist_ok=True)

EquiFashionDB_pipeline/standardize.py

@@ -18,7 +18,8 @@ def letterbox_square_bgr(bgr: np.ndarray, size: int) -> np.ndarray:
     nw = max(1, int(round(w * scale)))
     nh = max(1, int(round(h * scale)))
     resized = cv2.resize(bgr, (nw, nh), interpolation=cv2.INTER_AREA)
-    out = np.zeros((size, size, 3), dtype=np.uint8)
+    # Padding nền trắng để tránh viền đen ảnh hưởng Canny/edge.
+    out = np.full((size, size, 3), 255, dtype=np.uint8)
     pad_y = (size - nh) // 2
     pad_x = (size - nw) // 2
     out[pad_y : pad_y + nh, pad_x : pad_x + nw] = resized
@@ -35,3 +36,16 @@ def write_jpg(path: Path, bgr: np.ndarray, quality: int = 92) -> None:
     cv2.imwrite(str(path), bgr, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
 
 
+def write_image(path: Path, bgr: np.ndarray) -> None:
+    """
+    Write image using file extension.
+    Supports .jpg/.jpeg/.png/.webp (via OpenCV).
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    suf = path.suffix.lower()
+    if suf in {".jpg", ".jpeg"}:
+        write_jpg(path, bgr)
+        return
+    cv2.imwrite(str(path), bgr)
+
+