jp ocr ok

jp_ocr.py

@@ -5,6 +5,8 @@
 # 第一次 aliocr 识别中文   main.py
 # 第二次用 ppocr 识别日文  jp_ocr.py
 
+from ocr import rec as ppocr
+
 import json, cv2
 
 def save_json(filename, dics):
@@ -39,6 +41,7 @@ if __name__ == '__main__':
         jsn = item['js']
         imgData = np.fromfile(pth_img, dtype=np.uint8)
         img_color = cv2.imdecode(imgData, -1)
+
         if 'prism_wordsInfo' in jsn:
             wordsInfo = jsn['prism_wordsInfo']
         else:
@@ -85,8 +88,13 @@ if __name__ == '__main__':
             img_crop = img_color[lu[1]:lu[1]+(rd[1]-lu[1]), lu[0]:lu[0]+(rd[0]-lu[0])]
                 # img_crop = m4.ocr_frame[y:y+height, x:x+width]
             
-            cv2.imshow("img_crop", img_crop)
-            cv2.waitKey(0)
+            txts, boxes, scores, pil_image = ppocr(img_crop)
+            print( txts )
+            pass
+
+
+            # cv2.imshow("img_crop", img_crop)
+            # cv2.waitKey(0)
 
 
 
@@ -333,6 +341,9 @@ def ocr_one_pdf(pth_pdf):
             break
 
         img_color = get_page_image(reader, nth_page)
+
+        txts, boxes, scores, pil_image = ppocr( cv2.cvtColor(img_color, cv2.COLOR_RGB2BGR) )
+
         cv2.imwrite('./tmp.jpg', cv2.cvtColor(img_color, cv2.COLOR_RGB2BGR))
 
         # 把img 对象编码为jpg 格式
@@ -420,6 +431,8 @@ def ocr_one_pdf(pth_pdf):
             # img_color = cv2.rectangle(img_color, (x1, y1), (x2, y2), (0, 255, 0), 2)  # 矩形的左上角, 矩形的右下角
             img_color = cv2.rectangle(img_color, (lu[0], lu[1]), (rd[0], rd[1]), (0, 255, 0), 2)  # 矩形的左上角, 矩形的右下角
 
+
+
             # cv2.imshow("green", img_color)
             # cv2.waitKey(0)
 

ocr.py

@@ -0,0 +1,396 @@
+
+# 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)
+
+
+

requirements.txt

@@ -1,4 +1,72 @@
+
+
+######## jp_ocr begin ####################################################
 numpy==1.26.4
 opencv-python==4.6.0.66
 opencv-contrib-python==4.10.0.84
 pypdf[image]==5.0.0
+######## jp_ocr end ######################################################
+
+######### PaddleOCR_ali1k_det_rec_300epoch  begin ########################
+astor==0.8.1
+attrdict==2.0.1
+babel==2.16.0
+bce-python-sdk==0.9.21
+blinker==1.8.2
+cachetools==5.5.0
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.3.0
+cssselect==1.2.0
+cssutils==2.11.1
+cycler==0.12.1
+Cython==3.0.11
+decorator==5.1.1
+et-xmlfile==1.1.0
+Flask==3.0.3
+flask-babel==4.0.0
+fonttools==4.53.1
+future==1.0.0
+idna==3.8
+imageio==2.35.1
+imgaug==0.4.0
+itsdangerous==2.2.0
+Jinja2==3.1.4
+kiwisolver==1.4.5
+lazy_loader==0.4
+lmdb==1.5.1
+lxml==5.3.0
+MarkupSafe==2.1.5
+matplotlib==3.9.2
+more-itertools==10.4.0
+networkx==3.3
+numpy==1.26.4
+opencv-contrib-python==4.10.0.84
+opencv-python==4.6.0.66
+openpyxl==3.1.5
+opt-einsum==3.3.0
+packaging==24.1
+pillow==10.4.0
+premailer==3.10.0
+psutil==6.0.0
+pyclipper==1.3.0.post5
+pycryptodome==3.20.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+pytz==2024.1
+rapidfuzz==3.9.7
+rarfile==4.2
+requests==2.32.3
+scikit-image==0.24.0
+scipy==1.14.1
+shapely==2.0.6
+six==1.16.0
+tifffile==2024.8.30
+tqdm==4.66.5
+tzdata==2024.1
+urllib3==2.2.2
+Werkzeug==3.0.4
+######### PaddleOCR_ali1k_det_rec_300epoch  end   ########################
+
+