ocr.py

# proxychains4 pip install -r PaddleOCR_ali1k_det_rec_300epoch_standalone/requirements.txt

# PaddleOCR_ali1k_det_rec_300epoch/tools/infer/predict_system.py

__all__ = ['rec']  
    # 以”白名单“的形式暴露里面定义的符号

import os, sys

__dir__ = os.path.dirname(os.path.abspath(__file__))
# sys.path.append(__dir__)
sys.path.insert(0, os.path.abspath(os.path.join(__dir__, 'PaddleOCR_ali1k_det_rec_300epoch_standalone')))

os.environ["FLAGS_allocator_strategy"] = 'auto_growth'

import cv2
import copy
import numpy as np
import json
import time
import logging
from PIL import Image
import PaddleOCR_ali1k_det_rec_300epoch_standalone.tools.infer.utility as utility

import PaddleOCR_ali1k_det_rec_300epoch_standalone.tools.infer.predict_rec as predict_rec
import PaddleOCR_ali1k_det_rec_300epoch_standalone.tools.infer.predict_det as predict_det
import PaddleOCR_ali1k_det_rec_300epoch_standalone.tools.infer.predict_cls as predict_cls
from PaddleOCR_ali1k_det_rec_300epoch_standalone.ppocr.utils.utility import get_image_file_list, check_and_read
from PaddleOCR_ali1k_det_rec_300epoch_standalone.ppocr.utils.logging import get_logger
from PaddleOCR_ali1k_det_rec_300epoch_standalone.tools.infer.utility import draw_ocr_box_txt, get_rotate_crop_image
logger = get_logger()


class TextSystem(object):
    def __init__(self, args):
        if not args.show_log:
            logger.setLevel(logging.INFO)

        self.text_detector = predict_det.TextDetector(args)
        self.text_recognizer = predict_rec.TextRecognizer(args)
        self.use_angle_cls = args.use_angle_cls
        self.drop_score = args.drop_score
        if self.use_angle_cls:
            self.text_classifier = predict_cls.TextClassifier(args)

        self.args = args
        self.crop_image_res_index = 0

    def draw_crop_rec_res(self, output_dir, img_crop_list, rec_res):
        os.makedirs(output_dir, exist_ok=True)
        bbox_num = len(img_crop_list)
        for bno in range(bbox_num):
            cv2.imwrite(
                os.path.join(output_dir,
                             f"mg_crop_{bno+self.crop_image_res_index}.jpg"),
                img_crop_list[bno])
            logger.debug(f"{bno}, {rec_res[bno]}")
        self.crop_image_res_index += bbox_num

    def __call__(self, img, cls=True):
        time_dict = {'det': 0, 'rec': 0, 'csl': 0, 'all': 0}
        start = time.time()
        ori_im = img.copy()
        dt_boxes, elapse = self.text_detector(img)
        time_dict['det'] = elapse
        logger.debug("dt_boxes num : {}, elapse : {}".format(
            len(dt_boxes), elapse))
        if dt_boxes is None:
            return None, None
        img_crop_list = []

        dt_boxes = sorted_boxes(dt_boxes)

        for bno in range(len(dt_boxes)):
            tmp_box = copy.deepcopy(dt_boxes[bno])
            img_crop = get_rotate_crop_image(ori_im, tmp_box)
            img_crop_list.append(img_crop)
        if self.use_angle_cls and cls:
            img_crop_list, angle_list, elapse = self.text_classifier(
                img_crop_list)
            time_dict['cls'] = elapse
            logger.debug("cls num  : {}, elapse : {}".format(
                len(img_crop_list), elapse))

        rec_res, elapse = self.text_recognizer(img_crop_list)
        time_dict['rec'] = elapse
        logger.debug("rec_res num  : {}, elapse : {}".format(
            len(rec_res), elapse))
        if self.args.save_crop_res:
            self.draw_crop_rec_res(self.args.crop_res_save_dir, img_crop_list,
                                   rec_res)
        filter_boxes, filter_rec_res = [], []
        for box, rec_result in zip(dt_boxes, rec_res):
            text, score = rec_result
            if score >= self.drop_score:
                filter_boxes.append(box)
                filter_rec_res.append(rec_result)
        end = time.time()
        time_dict['all'] = end - start
        return filter_boxes, filter_rec_res, time_dict


def sorted_boxes(dt_boxes):
    """
    Sort text boxes in order from top to bottom, left to right
    args:
        dt_boxes(array):detected text boxes with shape [4, 2]
    return:
        sorted boxes(array) with shape [4, 2]
    """
    num_boxes = dt_boxes.shape[0]
    sorted_boxes = sorted(dt_boxes, key=lambda x: (x[0][1], x[0][0]))
    _boxes = list(sorted_boxes)

    for i in range(num_boxes - 1):
        for j in range(i, 0, -1):
            if abs(_boxes[j + 1][0][1] - _boxes[j][0][1]) < 10 and \
                    (_boxes[j + 1][0][0] < _boxes[j][0][0]):
                tmp = _boxes[j]
                _boxes[j] = _boxes[j + 1]
                _boxes[j + 1] = tmp
            else:
                break
    return _boxes


def main(args):
    image_file_list = get_image_file_list(args.image_dir)
    image_file_list = image_file_list[args.process_id::args.total_process_num]
    text_sys = TextSystem(args)
    is_visualize = True
    font_path = args.vis_font_path
    drop_score = args.drop_score
    draw_img_save_dir = args.draw_img_save_dir
    os.makedirs(draw_img_save_dir, exist_ok=True)
    save_results = []

    logger.info(
        "In PP-OCRv3, rec_image_shape parameter defaults to '3, 48, 320', "
        "if you are using recognition model with PP-OCRv2 or an older version, please set --rec_image_shape='3,32,320"
    )

    # warm up 10 times
    if args.warmup:
        img = np.random.uniform(0, 255, [640, 640, 3]).astype(np.uint8)
        for i in range(10):
            res = text_sys(img)

    total_time = 0
    cpu_mem, gpu_mem, gpu_util = 0, 0, 0
    _st = time.time()
    count = 0
    for idx, image_file in enumerate(image_file_list):

        img, flag, _ = check_and_read(image_file)
        if not flag:
            img = cv2.imread(image_file)
        if img is None:
            logger.debug("error in loading image:{}".format(image_file))
            continue
        starttime = time.time()
        dt_boxes, rec_res, time_dict = text_sys(img)
        elapse = time.time() - starttime
        total_time += elapse

        logger.debug(
            str(idx) + "  Predict time of %s: %.3fs" % (image_file, elapse))
        for text, score in rec_res:
            logger.debug("{}, {:.3f}".format(text, score))

        res = [{
            "transcription": rec_res[idx][0],
            "points": np.array(dt_boxes[idx]).astype(np.int32).tolist(),
        } for idx in range(len(dt_boxes))]
        save_pred = os.path.basename(image_file) + "\t" + json.dumps(
            res, ensure_ascii=False) + "\n"
        save_results.append(save_pred)

        if is_visualize:
            image = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
            boxes = dt_boxes
            txts = [rec_res[i][0] for i in range(len(rec_res))]
            scores = [rec_res[i][1] for i in range(len(rec_res))]

            draw_img = draw_ocr_box_txt(
                image,
                boxes,
                txts,
                scores,
                drop_score=drop_score,
                font_path=font_path)
            if flag:
                image_file = image_file[:-3] + "png"
            cv2.imwrite(
                os.path.join(draw_img_save_dir, os.path.basename(image_file)),
                draw_img[:, :, ::-1])
            logger.debug("The visualized image saved in {}".format(
                os.path.join(draw_img_save_dir, os.path.basename(image_file))))

    logger.info("The predict total time is {}".format(time.time() - _st))
    if args.benchmark:
        text_sys.text_detector.autolog.report()
        text_sys.text_recognizer.autolog.report()

    with open(
            os.path.join(draw_img_save_dir, "system_results.txt"),
            'w',
            encoding='utf-8') as f:
        f.writelines(save_results)

class AttributeDict(dict):
    def __getattr__(self, attr):
        return self[attr]
    def __setattr__(self, attr, value):
        self[attr] = value

# sysargv = ['--image_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/train_data/det/train/3.jpg', '--det_algorithm', 'DB', '--det_model_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_det_infer', '--det_limit_side_len', '1024', '--det_db_unclip_ratio', '3.5', '--rec_model_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_rec_infer', '--rec_char_dict_path', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ppocr_keys.txt', '--use_gpu', 'False', '--enable_mkldnn', 'True', '--vis_font_path', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/fonts/simfang.ttf']
    # ch
sysargv = ['--image_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/train_data/det/train/3.jpg', '--det_algorithm', 'DB', '--det_model_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_det_infer', '--det_limit_side_len', '1024', '--det_db_unclip_ratio', '3.5', '--rec_model_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/japan_PP-OCRv3_rec_infer', '--rec_char_dict_path', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/japan_dict.txt', '--use_gpu', 'False', '--enable_mkldnn', 'True', '--vis_font_path', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/fonts/simfang.ttf']
    # jp
args = utility.parse_args(sysargv)
text_sys = TextSystem(args)
def rec(img: str | cv2.typing.MatLike):

    if isinstance(img, (str)):
        img = cv2.imread(img)

    dt_boxes, rec_res, time_dict = text_sys(img)
    
    res = [{
        "transcription": rec_res[idx][0],
        "points": np.array(dt_boxes[idx]).astype(np.int32).tolist(),
    } for idx in range(len(dt_boxes))]
    
    pil_image = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))    
    boxes = dt_boxes
    txts = [rec_res[i][0] for i in range(len(rec_res))]
    scores = [rec_res[i][1] for i in range(len(rec_res))]
    return txts, boxes, scores, pil_image

def showBox(txts, boxes, scores, pil_image):
    
    draw_img = draw_ocr_box_txt(
        pil_image,
        boxes,
        txts,
        scores,
        drop_score=0.5,
        font_path='PaddleOCR_ali1k_det_rec_300epoch_standalone/fonts/simfang.ttf'
    )

    cv2.imshow("result", draw_img)
    cv2.waitKey(0)


if __name__ == "__main__":
    
    # text_detector = predict_det.TextDetector( AttributeDict({"det_algorithm": "DB"}) )
    #text_recognizer = predict_rec.TextRecognizer(args)
    
    # img = cv2.imread(image_file)
    # starttime = time.time()
    # dt_boxes, rec_res, time_dict = text_sys(img)
    # elapse = time.time() - starttime
    
    
    """
    python3 tools/infer/predict_system.py \
    --image_dir="train_data/det/test/25.jpg" \
    --det_algorithm="DB" \
    --det_model_dir="output/det_model" \
    --det_limit_side_len=960 \
    --det_db_unclip_ratio=3.5 \
    --rec_model_dir="output/rec_model/Student" \
    --rec_char_dict_path="train_data/keys.txt" \
    --use_gpu False \
    --enable_mkldnn=True
    
    """
    # import sys
    # sys.argv.append( '--image_dir' )
    # # sys.argv.append( 'train_data/det/test/12.jpg' )
    # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch_standalone/train_data/det/train/3.jpg' )
    # sys.argv.append( '--det_algorithm' )
    # sys.argv.append( 'DB' )
    # sys.argv.append( '--det_model_dir' )
    # # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch/output/det_model' )  # 自已训练的
    # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_det_infer' ) # 官方的
    # sys.argv.append( '--det_limit_side_len' )
    # # sys.argv.append( '960' ) # 自已的
    # sys.argv.append( '1024' ) # 官方的
    # sys.argv.append( '--det_db_unclip_ratio' )
    # sys.argv.append( '3.5' )
    # sys.argv.append( '--rec_model_dir' )
    # # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch/output/rec_model/Student' ) # 自已的
    # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_rec_infer' ) # 官方的
    # sys.argv.append( '--rec_char_dict_path' )
    # # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch/train_data/keys.txt' ) # 自已的 
    # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ppocr_keys.txt' ) # 官方的词表
    # sys.argv.append( '--use_gpu' )
    # sys.argv.append( 'False' )
    # sys.argv.append( '--enable_mkldnn' )
    # sys.argv.append( 'True' )
    # sys.argv.append( '--vis_font_path' )
    # sys.argv.append( 'PaddleOCR_ali1k_det_rec_300epoch_standalone/fonts/simfang.ttf' )
    
    sysargv = ['--image_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/train_data/det/train/3.jpg', '--det_algorithm', 'DB', '--det_model_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_det_infer', '--det_limit_side_len', '1024', '--det_db_unclip_ratio', '3.5', '--rec_model_dir', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ch_PP-OCRv3_rec_infer', '--rec_char_dict_path', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/official_models/ppocr_keys.txt', '--use_gpu', 'False', '--enable_mkldnn', 'True', '--vis_font_path', 'PaddleOCR_ali1k_det_rec_300epoch_standalone/fonts/simfang.ttf']
    # args = utility.parse_args()
    args = utility.parse_args(sysargv)
    
    text_sys = TextSystem(args)
    img = cv2.imread('PaddleOCR_ali1k_det_rec_300epoch_standalone/train_data/det/train/3.jpg')
    #img = cv2.imread('images/ch.png')

    dt_boxes, rec_res, time_dict = text_sys(img)
    
    res = [{
        "transcription": rec_res[idx][0],
        "points": np.array(dt_boxes[idx]).astype(np.int32).tolist(),
    } for idx in range(len(dt_boxes))]
    
    image = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))    
    boxes = dt_boxes
    txts = [rec_res[i][0] for i in range(len(rec_res))]
    scores = [rec_res[i][1] for i in range(len(rec_res))]

    font_path = args.vis_font_path
    drop_score = args.drop_score
    draw_img = draw_ocr_box_txt(
        image,
        boxes,
        txts,
        scores,
        drop_score=drop_score,
        font_path=font_path)
    
    # 缩放图片, 统一 800 宽
    height, width, colorNum = img.shape
    
    newWidth = 800
    if width > newWidth: 
        rate = newWidth / width
        newHeight = int(rate * height) 
        dim = (newWidth, newHeight)
        img_des = cv2.resize(draw_img, dim, interpolation=cv2.INTER_LINEAR) #img.resize (new OpenCvSharp.Size(0, 0), rate, rate, InterpolationFlags.Linear);
    else:
        img_des = draw_img.copy()    
    
    cv2.imshow("result", draw_img)
    cv2.waitKey(0)
    
    main(args)
    























# pip install paddlepaddle "paddleocr==2.7.0.0" -i https://mirror.baidu.com/pypi/simple

# apt install python3.10-dev

# pip install paddlepaddle "paddleocr==2.7.5" -i https://mirror.baidu.com/pypi/simple

# from paddleocr import PaddleOCR, draw_ocr

# # `ch`, `en`, `fr`, `german`, `korean`, `japan`
# ocr = PaddleOCR(use_angle_cls=True, lang="ch")  # need to run only once to download and load model into memory
# img_path = './images/ch.png'
# result = ocr.ocr(img_path, cls=True)
# for idx in range(len(result)):
#     res = result[idx]
#     for line in res:
#         print(line)