|
|
import os |
|
|
import os.path as osp |
|
|
from typing import Tuple, List |
|
|
|
|
|
import torch |
|
|
import numpy as np |
|
|
import cv2 |
|
|
|
|
|
from .base import register_textdetectors, TextDetectorBase, TextBlock, DEVICE_SELECTOR |
|
|
from utils.textblock import mit_merge_textlines, sort_regions, examine_textblk, sort_pnts |
|
|
from utils.imgproc_utils import xywh2xyxypoly |
|
|
from utils.proj_imgtrans import ProjImgTrans |
|
|
|
|
|
MODEL_DIR = 'data/models' |
|
|
CKPT_LIST = [] |
|
|
|
|
|
def update_ckpt_list(): |
|
|
if not osp.exists(MODEL_DIR): |
|
|
return |
|
|
global CKPT_LIST |
|
|
CKPT_LIST.clear() |
|
|
for p in os.listdir(MODEL_DIR): |
|
|
if p.startswith('ysgyolo') or p.startswith('ultralyticsyolo'): |
|
|
CKPT_LIST.append(osp.join(MODEL_DIR, p).replace('\\', '/')) |
|
|
|
|
|
|
|
|
update_ckpt_list() |
|
|
|
|
|
@register_textdetectors('ysgyolo') |
|
|
class YSGYoloDetector(TextDetectorBase): |
|
|
params = { |
|
|
'model path': { |
|
|
'type': 'selector', |
|
|
'options': CKPT_LIST, |
|
|
'value': 'data/models/ysgyolo_1.2_OS1.0.pt', |
|
|
'editable': True, |
|
|
'flush_btn': True, |
|
|
'path_selector': True, |
|
|
'path_filter': '*.pt *.ckpt *.pth *.safetensors', |
|
|
'size': 'median', |
|
|
'display_name': '模型路径' |
|
|
}, |
|
|
'merge text lines': { |
|
|
'display_name': '合并文本行', 'type': 'checkbox', 'value': True |
|
|
}, |
|
|
'confidence threshold': { |
|
|
'display_name': '置信度阈值', 'type': 'line_editor', 'value': 0.3 |
|
|
}, |
|
|
'IoU threshold': { |
|
|
'display_name': 'IoU阈值', 'type': 'line_editor', 'value': 0.5 |
|
|
}, |
|
|
'font size multiplier': { |
|
|
'display_name': '字号乘数', 'type': 'line_editor', 'value': 1. |
|
|
}, |
|
|
'font size max': { |
|
|
'display_name': '最大字号', 'type': 'line_editor', 'value': -1 |
|
|
}, |
|
|
'font size min': { |
|
|
'display_name': '最小字号', 'type': 'line_editor', 'value': -1 |
|
|
}, |
|
|
'detect size': { |
|
|
'display_name': '检测尺寸', 'type': 'line_editor', 'value': 1024 |
|
|
}, |
|
|
'device': { |
|
|
**DEVICE_SELECTOR(), |
|
|
'display_name': '设备' |
|
|
}, |
|
|
'label': { |
|
|
'value': { |
|
|
'balloon': True, |
|
|
'qipao': True, |
|
|
'shuqing': True, |
|
|
'changfangtiao': True, |
|
|
'hengxie': True, |
|
|
'other': True |
|
|
}, |
|
|
'type': 'check_group', |
|
|
'display_name': '标签' |
|
|
}, |
|
|
'source text is vertical': { |
|
|
'display_name': '竖排文本', 'type': 'checkbox', 'value': True |
|
|
}, |
|
|
'mask dilate size': { |
|
|
'display_name': '掩码扩张尺寸', 'type': 'line_editor', 'value': 2 |
|
|
} |
|
|
} |
|
|
|
|
|
_load_model_keys = {'model'} |
|
|
|
|
|
def __init__(self, **params) -> None: |
|
|
super().__init__(**params) |
|
|
update_ckpt_list() |
|
|
|
|
|
def _load_model(self): |
|
|
model_path = self.get_param_value('model path') |
|
|
if not osp.exists(model_path): |
|
|
global CKPT_LIST |
|
|
df_model_path = model_path |
|
|
for p in CKPT_LIST: |
|
|
if osp.exists(p): |
|
|
df_model_path = p |
|
|
break |
|
|
self.logger.warning(f'{model_path} does not exist, try fall back to default value {df_model_path}') |
|
|
model_path = df_model_path |
|
|
|
|
|
if 'rtdetr' in os.path.basename(model_path): |
|
|
from ultralytics import RTDETR as MODEL |
|
|
else: |
|
|
from ultralytics import YOLO as MODEL |
|
|
if not hasattr(self, 'model') or self.model is None: |
|
|
self.model = MODEL(model_path).to(device=self.get_param_value('device')) |
|
|
|
|
|
def get_valid_labels(self): |
|
|
return [k for k, v in self.params['label']['value'].items() if v] |
|
|
|
|
|
@property |
|
|
def is_ysg(self): |
|
|
return osp.basename(self.get_param_value('model path').startswith('ysg')) |
|
|
|
|
|
def _detect(self, img: np.ndarray, proj: ProjImgTrans = None) -> Tuple[np.ndarray, List[TextBlock]]: |
|
|
result = self.model.predict( |
|
|
source=img, save=False, show=False, verbose=False, |
|
|
conf=self.get_param_value('confidence threshold'), iou=self.get_param_value('IoU threshold'), |
|
|
agnostic_nms=True |
|
|
)[0] |
|
|
|
|
|
valid_labels = set(self.get_valid_labels()) |
|
|
valid_ids = [idx for idx, name in result.names.items() if name in valid_labels] |
|
|
|
|
|
mask = np.zeros_like(img[..., 0]) |
|
|
if not valid_ids: |
|
|
return [], mask |
|
|
|
|
|
im_h, im_w = img.shape[:2] |
|
|
detected_items = [] |
|
|
|
|
|
|
|
|
dets = result.boxes |
|
|
if dets is not None and len(dets.cls) > 0: |
|
|
for i in range(len(dets.cls)): |
|
|
cls_idx = int(dets.cls[i]) |
|
|
if cls_idx in valid_ids: |
|
|
label_name = result.names[cls_idx] |
|
|
|
|
|
xyxy = dets.xyxy[i].cpu().numpy() |
|
|
x1, y1, x2, y2 = xyxy.astype(int) |
|
|
cv2.rectangle(mask, (x1, y1), (x2, y2), 255, -1) |
|
|
pts = xywh2xyxypoly(np.array([[x1, y1, x2 - x1, y2 - y1]])).reshape(4, 2).tolist() |
|
|
detected_items.append({'pts': pts, 'label': label_name}) |
|
|
|
|
|
|
|
|
dets = result.obb |
|
|
if dets is not None and len(dets.cls) > 0: |
|
|
for i in range(len(dets.cls)): |
|
|
cls_idx = int(dets.cls[i]) |
|
|
if cls_idx in valid_ids: |
|
|
label_name = result.names[cls_idx] |
|
|
pts = dets.xyxyxyxy[i].cpu().numpy().astype(int) |
|
|
cv2.fillPoly(mask, [pts], 255) |
|
|
detected_items.append({'pts': pts.tolist(), 'label': label_name}) |
|
|
|
|
|
blk_list = [] |
|
|
if self.get_param_value('merge text lines'): |
|
|
pts_only_list = [item['pts'] for item in detected_items] |
|
|
blk_list = mit_merge_textlines(pts_only_list, width=im_w, height=im_h) |
|
|
else: |
|
|
for item in detected_items: |
|
|
|
|
|
pts_sorted, is_vertical = sort_pnts(item['pts']) |
|
|
blk = TextBlock(lines=[pts_sorted], src_is_vertical=is_vertical, label=item['label']) |
|
|
blk.vertical = is_vertical |
|
|
blk.adjust_bbox() |
|
|
examine_textblk(blk, im_w, im_h) |
|
|
blk_list.append(blk) |
|
|
|
|
|
blk_list = sort_regions(blk_list) |
|
|
|
|
|
fnt_rsz = self.get_param_value('font size multiplier') |
|
|
fnt_max = self.get_param_value('font size max') |
|
|
fnt_min = self.get_param_value('font size min') |
|
|
for blk in blk_list: |
|
|
sz = blk._detected_font_size * fnt_rsz |
|
|
if fnt_max > 0: |
|
|
sz = min(fnt_max, sz) |
|
|
if fnt_min > 0: |
|
|
sz = max(fnt_min, sz) |
|
|
blk.font_size = sz |
|
|
blk._detected_font_size = sz |
|
|
|
|
|
ksize = self.get_param_value('mask dilate size') |
|
|
if ksize > 0: |
|
|
element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * ksize + 1, 2 * ksize + 1), (ksize, ksize)) |
|
|
mask = cv2.dilate(mask, element) |
|
|
|
|
|
return mask, blk_list |
|
|
|
|
|
def updateParam(self, param_key: str, param_content): |
|
|
super().updateParam(param_key, param_content) |
|
|
|
|
|
if param_key == 'model path': |
|
|
if hasattr(self, 'model'): |
|
|
del self.model |
|
|
|
|
|
def flush(self, param_key: str): |
|
|
if param_key == 'model path': |
|
|
update_ckpt_list() |
|
|
global CKPT_LIST |
|
|
return CKPT_LIST |
