update

 model_repository/
 model_repository/
-
+__pycache__/

+# turnsole
+A series of convenience functions make your machine learning project easier 
+
+## 安装方法
+
+### Latest release
+`pip install turnsole`
+> 项目暂不开源，因此该安装方法暂时不保证能用
+
+### Developer mode
+
+`pip install -e .`
+
+## 快速上手
+### PDF 操作 
+#### 智能 PDF 文件转图片
+智能的把 PDF 文件里面的插图找出来，例如没有插图就将整页 PDF 截图下来，也能智能的将碎图拼接在一起
+
+##### Example:
+<pre># pdf_path 表示 PDF 文件的路径，输出 images 按页码进行汇总输出
+images = turnsole.pdf_to_images(pdf_path)</pre>
+
+### 图像操作工具箱 
+#### base64_to_bgr / bgr_to_base64
+图像和 base64 互相转换
+
+##### Example:
+<pre>image = turnsole.base64_to_bgr(img64)
+img64 = turnsole.bgr_to_base64(image)</pre>
+
+### image_crop
+根据 bbox 在 image 上进行切片，如果指定 perspective 为 True 则切片方式为透视变换（可以切旋转目标）
+
+##### Example:
+<pre>im_slice_no_perspective = turnsole.image_crop(image, bbox)
+im_slice = turnsole.image_crop(image, bbox, perspective=True)</pre>
+
+##### Output:
+
+<img src="docs/images/image_crop.png?raw=true" alt="image crop example" style="max-width: 200px;">
+
+### OCR 引擎模块 
+OCR 引擎指的是一系列跟 OCR 相关的底层模型，我们提供了这些模型的函数式调用接口和标准 API 
+
+- [x] ADC :tada:
+- [x] DBNet :tada:
+- [x] CRNN :tada:
+- [x] Object Detector :tada:
+- [x] Signature Detector :tada:
+
+#### 免费试用
+```python
+import requests
+
+results = requests.post(url=r'http://139.196.149.46:9001/gen_ocr', files={'file': open(file_path, 'rb')}).json()
+ocr_results = results['ocr_results']
+```
+
+#### Prerequisites
+由于 OCR 引擎模块依赖于底层神经网络模型，因此需要先用 Docker 挂载底层神经网络模型 
+
+首先把 ./model_repository 文件夹和里面的模型放到项目根目录下再启动，如果没有相关模型找 [lvkui](lvkui@situdata.com) 要 
+
+使用起来非常简单，你只需要启动对应的 Docker 容器即可
+
+```bash
+docker run --gpus="device=0" --rm -p 8000:8000 -p 8001:8001 -p 8002:8002 -v $PWD/model_repository:/models nvcr.io/nvidia/tritonserver:21.10-py3 tritonserver --model-repository=/models
+```
+
+#### ADC
+通用文件摆正算法
+
+``` 
+from turnsole.ocr_engine import angle_detector
+
+image_rotated, direction = angle_detector.ADC(image, fine_degree=False)
+```
+
+#### DBNet
+通用文字检测算法
+
+``` 
+from turnsole.ocr_engine import text_detector
+
+boxes = text_detector.predict(image)
+```
+
+#### CRNN
+通用文字识别算法
+
+``` 
+from turnsole.ocr_engine import text_recognizer
+
+ocr_result, ocr_time = text_recognizer.predict_batch(image, boxes)
+```
+
+#### Object Detector
+通用文件检测算法
+
+``` 
+from turnsole.ocr_engine import object_detector
+
+object_list = object_detector.process(image)
+```
+
+#### Signature Detector
+签字盖章二维码检测算法
+
+``` 
+from turnsole.ocr_engine import signature_detector
+
+signature_list = signature_detector.process(image)
+```
+
+#### 标准 API
+```
+python api/ocr_engine_server.py
+```
\ No newline at end of file

+[2022-10-21 14:12:17 +0800] [8546] [INFO] Goin' Fast @ http://192.168.10.11:9001
+[2022-10-21 14:12:17 +0800] [8567] [INFO] Starting worker [8567]
+[2022-10-21 14:12:17 +0800] [8568] [INFO] Starting worker [8568]
+[2022-10-21 14:12:17 +0800] [8569] [INFO] Starting worker [8569]
+[2022-10-21 14:12:17 +0800] [8570] [INFO] Starting worker [8570]
+[2022-10-21 14:12:17 +0800] [8571] [INFO] Starting worker [8571]
+[2022-10-21 14:12:17 +0800] [8572] [INFO] Starting worker [8572]
+[2022-10-21 14:12:17 +0800] [8573] [INFO] Starting worker [8573]
+[2022-10-21 14:12:17 +0800] [8576] [INFO] Starting worker [8576]
+[2022-10-21 14:12:17 +0800] [8574] [INFO] Starting worker [8574]
+[2022-10-21 14:12:17 +0800] [8575] [INFO] Starting worker [8575]
+[2022-10-21 14:13:51 +0800] [8575] [ERROR] Exception occurred while handling uri: 'http://192.168.10.11:9001/gen_ocr'
+Traceback (most recent call last):
+  File "/home/situ/miniconda3/envs/workenv/lib/python3.6/site-packages/sanic/app.py", line 944, in handle_request
+    response = await response
+  File "ocr_engine_server.py", line 37, in ocr_engine
+    boxes = text_detector.predict(image)
+  File "/home/situ/qfs/invoice_tamper/09_project/project/bank_bill_ocr/OCR_Engine/turnsole/ocr_engine/DBNet/text_detector.py", line 113, in predict
+    outputs=outputs
+  File "/home/situ/miniconda3/envs/workenv/lib/python3.6/site-packages/tritonclient/grpc/__init__.py", line 1431, in infer
+    raise_error_grpc(rpc_error)
+  File "/home/situ/miniconda3/envs/workenv/lib/python3.6/site-packages/tritonclient/grpc/__init__.py", line 62, in raise_error_grpc
+    raise get_error_grpc(rpc_error) from None
+tritonclient.utils.InferenceServerException: [StatusCode.UNAVAILABLE] Request for unknown model: 'dbnet_model' is not found
+[2022-10-21 14:13:51 +0800] - (sanic.access)[INFO][192.168.10.11:57260]: POST http://192.168.10.11:9001/gen_ocr  500 735

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-06-05 20:49:51
+# @Last Modified : 2022-08-19 17:24:55
+# @Description   : 
+
+import os
+
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+from sanic import Sanic
+from sanic.response import json
+
+from turnsole.ocr_engine import angle_detector
+from turnsole.ocr_engine import text_detector
+from turnsole.ocr_engine import text_recognizer
+from turnsole.ocr_engine import object_detector
+from turnsole.ocr_engine import signature_detector
+
+from turnsole import bytes_to_bgr
+
+app = Sanic("OCR_ENGINE")
+app.config.REQUEST_MAX_SIZE = 1000000000  # 请求的大小（字节）/ 1GB
+app.config.REQUEST_BUFFER_QUEUE_SIZE = 1000  # 请求流缓冲区队列大小
+app.config.REQUEST_TIMEOUT = 600  # 请求到达需要多长时间（秒）
+app.config.RESPONSE_TIMEOUT = 600  # 处理响应需要多长时间（秒）
+
+
+@app.post('/gen_ocr')
+async def ocr_engine(request):
+    # request.files.get() 具有 type/body/name 三个属性
+    file = request.files.get('file').body
+    # 将 bytes 转成 bgr 图片
+    image = bytes_to_bgr(file)
+    # 文字检测
+    boxes = text_detector.predict(image)
+    # 文字识别
+    res, _ = text_recognizer.predict_batch(image[..., ::-1], boxes)
+    resp = {}
+    resp["ocr_results"] = res
+    return json(resp)
+
+
+@app.post('/gen_ocr_with_rotation', )
+async def ocr_engine_with_rotation(request):
+    # request.files.get() 具有 type/body/name 三个属性
+    file = request.files.get('file').body
+    # 将 bytes 转成 bgr 图片
+    image = bytes_to_bgr(file)
+    # 方向检测
+    image, direction = angle_detector.ADC(image.copy(), fine_degree=False)
+    # 文字检测
+    boxes = text_detector.predict(image)
+    # 文字识别
+    res, _ = text_recognizer.predict_batch(image[..., ::-1], boxes)
+
+    resp = {}
+    resp["ocr_results"] = res
+    resp["direction"] = direction
+    return json(resp)
+
+
+@app.post("/object_detect")
+async def object_detect(request):
+    # request.files.get() 具有 type/body/name 三个属性
+    file = request.files.get('file').body
+    # 将 bytes 转成 bgr 图片
+    image = bytes_to_bgr(file)
+    # 通用文件检测
+    object_list = object_detector.process(image)
+    return json(object_list)
+
+
+@app.post("/signature_detect")
+async def signature_detect(request):
+    # request.files.get() 具有 type/body/name 三个属性
+    file = request.files.get('file').body
+    # 将 bytes 转成 bgr 图片
+    image = bytes_to_bgr(file)
+    # 签字盖章二维码条形码检测
+    signature_list = signature_detector.process(image)
+    return json(signature_list)
+
+
+if __name__ == "__main__":
+    # app.run(host="0.0.0.0", port=9001)
+    app.run(host="192.168.10.11", port=9002, workers=10)
+    # uvicorn server:app --port 9001 --workers 10

+# Modified from: 
+# https://www.pyimagesearch.com/2017/02/06/faster-video-file-fps-with-cv2-videocapture-and-opencv/
+
+# Performance:
+#    Python 2.7: 105.78   --> 131.75
+#    Python 3.7:  15.36   -->  50.13
+
+# USAGE
+# python read_frames_fast.py --video videos/jurassic_park_intro.mp4
+
+# import the necessary packages
+from turnsole.video import FileVideoStream
+from turnsole.video import FPS
+import numpy as np
+import argparse
+import imutils
+import time
+import cv2
+
+def filterFrame(frame):
+	frame = imutils.resize(frame, width=450)
+	frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+	frame = np.dstack([frame, frame, frame])
+	return frame
+
+# construct the argument parse and parse the arguments
+ap = argparse.ArgumentParser()
+ap.add_argument("-v", "--video", required=True,
+	help="path to input video file")
+args = vars(ap.parse_args())
+
+# start the file video stream thread and allow the buffer to
+# start to fill
+print("[INFO] starting video file thread...")
+fvs = FileVideoStream(args["video"], transform=filterFrame).start()
+time.sleep(1.0)
+
+# start the FPS timer
+fps = FPS().start()
+
+# loop over frames from the video file stream
+while fvs.running():
+	# grab the frame from the threaded video file stream, resize
+	# it, and convert it to grayscale (while still retaining 3
+	# channels)
+	frame = fvs.read()
+
+	# Relocated filtering into producer thread with transform=filterFrame
+	#  Python 2.7: FPS 92.11 -> 131.36
+	#  Python 3.7: FPS 41.44 -> 50.11
+	#frame = filterFrame(frame)
+
+	# display the size of the queue on the frame
+	cv2.putText(frame, "Queue Size: {}".format(fvs.Q.qsize()),
+		(10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)	
+
+	# show the frame and update the FPS counter
+	cv2.imshow("Frame", frame)
+
+	cv2.waitKey(1)
+	if fvs.Q.qsize() < 2:  # If we are low on frames, give time to producer
+		time.sleep(0.001)  # Ensures producer runs now, so 2 is sufficient
+	fps.update()
+
+# stop the timer and display FPS information
+fps.stop()
+print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
+print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
+
+# do a bit of cleanup
+cv2.destroyAllWindows()
+fvs.stop()
\ No newline at end of file

+import cv2
+import turnsole
+
+if __name__ == '__main__':
+	img = cv2.imread('./images/sunflower.jpg')
+	img = turnsole.resize(img, width=512)
+	cv2.imshow('image', img)
+	cv2.waitKey()

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Created Date  : 2021-03-05 16:51:22
+# @Last Modified : 2021-03-05 18:15:53
+# @Description   :
+
+from turnsole.model import EasyDet
+
+if __name__ == '__main__':
+    model = EasyDet(phi=0)
+    model.summary()
+
+    import time
+    import numpy as np
+
+    x = np.random.random_sample((1, 640, 640, 3))
+    # warm up
+    output = model.predict(x)
+
+    print('\n[INFO] Test start')
+    time_start = time.time()
+    for i in range(1000):
+        output = model.predict(x)
+        
+        time_end = time.time()
+        print('[INFO] Time used: {:.2f} ms'.format((time_end - time_start)*1000/(i+1)))
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-07-22 13:10:47
+# @Last Modified : 2022-09-08 19:03:24
+# @Description   : 
+
+import os
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+import cv2
+# from turnsole.ocr_engine import angle_detector
+from turnsole.ocr_engine import object_detector
+import matplotlib.pyplot as plt
+
+
+if __name__ == "__main__":
+
+    base_dir = '/home/lk/MyProject/BMW/数据集/文件分类/身份证'
+
+    for (rootDir, dirNames, filenames) in os.walk(base_dir):
+
+        for filename in filenames:
+        
+            if not filename.endswith('.jpg'):
+                continue
+
+            img_path = os.path.join(rootDir, filename)
+            print(img_path)
+
+            image = cv2.imread(img_path)
+            
+            results = object_detector.process(image)
+
+            print(results)
+
+            for item in results:
+                xmin = item['location']['xmin']
+                ymin = item['location']['ymin']
+                xmax = item['location']['xmax']
+                ymax = item['location']['ymax']
+                cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)
+
+            plt.imshow(image[...,::-1])
+            plt.show()
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-07-22 13:10:47
+# @Last Modified : 2022-08-24 15:39:55
+# @Description   : 
+
+
+import os
+import cv2
+import fitz
+from turnsole import pdf_to_images      # pip install turnsole PyMuPDF opencv-python==4.4.0.44
+
+if __name__ == "__main__":
+
+    base_dir = '/PATH/TO/YOUR/WORKDIR'
+
+    for (rootDir, dirNames, filenames) in os.walk(base_dir):
+
+        for filename in filenames:
+        
+            if not filename.endswith('.pdf'):
+                continue
+
+            pdf_path = os.path.join(rootDir, filename)
+            print(pdf_path)
+
+            images = pdf_to_images(pdf_path)
+            images = sum(images, [])
+
+            image_dir = os.path.join(rootDir, filename.replace('.pdf', ''))
+            if not os.path.exists(image_dir):
+                os.makedirs(image_dir)
+
+            for index, image in enumerate(images):
+
+                save_path = os.path.join(image_dir, filename.replace('.pdf', '')+'-'+str(index)+'.jpg')
+                cv2.imwrite(save_path, image)

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-05-06 22:02:01
+# @Last Modified : 2022-08-03 14:59:51
+# @Description   : 
+
+
+import os
+import time
+import random
+import requests
+import numpy as np
+from threading import Thread
+
+
+class API_test:
+    def __init__(self, file_dir, test_time, num_request):
+        
+        self.file_paths = []
+        for fn in os.listdir(file_dir):
+            file_path = os.path.join(file_dir, fn)
+            self.file_paths.append(file_path)
+
+        self.time_start = time.time()
+        self.test_time = test_time * 60                  # 单位:秒
+        threads = []
+        for i in range(num_request):
+            t = Thread(target=self.update, args=())
+            threads.append(t)
+        for t in threads:
+            print(f'[INFO] {t} is running')
+            t.start()
+        self.results = list()
+        self.index = 0
+
+    def update(self):
+        while True:
+            file_path = random.choice(self.file_paths)
+
+            # 二进制方式打开图片文件
+            data = open(file_path, 'rb')
+
+            t0 = time.time()
+            response = requests.post(url=r'http://localhost:9001/gen_ocr_with_rotation', files={'file': data})
+
+            # 失败请求统计
+            if response.status_code != 200:
+                print(response)
+
+            t1 = time.time()
+            self.results.append((t1-t0))
+
+            time_cost = (time.time() - self.time_start)
+            time_remaining = self.test_time - time_cost
+
+            self.index += 1
+
+            if time_remaining > 0:
+                print(f'\r[INFO] 剩余时间 {time_remaining} 秒, 平均响应时间 {np.mean(self.results)} 秒， TPS {len(self.results)/time_cost}， 吞吐量 {self.index}', end='   ', flush=True)
+            else:
+                break
+
+
+if __name__ == '__main__':
+
+    imageDir = './demos/img_ocr'           # 测试数据路径
+    testTime = 10                                                       # 加压时间, 单位：分钟
+    numRequest = 10                                                     # 并发数，单位：个
+
+    API_test(imageDir, testTime, numRequest)

+[metadata]
+name = turnsole
+version = 0.0.27
+author = Kui Lyu
+author_email = 9428.al@gmail.com
+description = A series of convenience functions make your machine learning project easier
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/Antonio-hi/turnsole
+project_urls =
+    Bug Tracker = https://github.com/Antonio-hi/turnsole/issues
+classifiers =
+    Programming Language :: Python :: 3
+    License :: OSI Approved :: MIT License
+    Operating System :: OS Independent
+
+[options]
+packages = find:
+python_requires = >=3.6
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : lk
+# @Email         : 9428.al@gmail.com
+# @Created Date  : 2021-03-04 16:56:27
+# @Last Modified : 2021-03-04 17:16:57
+# @Description   :
+
+import setuptools
+
+setuptools.setup()
\ No newline at end of file

+Metadata-Version: 2.1
+Name: turnsole
+Version: 0.0.27
+Summary: A series of convenience functions make your machine learning project easier
+Home-page: https://github.com/Antonio-hi/turnsole
+Author: Kui Lyu
+Author-email: 9428.al@gmail.com
+License: UNKNOWN
+Project-URL: Bug Tracker, https://github.com/Antonio-hi/turnsole/issues
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# turnsole
+A series of convenience functions make your machine learning project easier 
+
+## 安装方法
+
+### Latest release
+`pip install turnsole`
+> 项目暂不开源，因此该安装方法暂时不保证能用
+
+### Developer mode
+
+`pip install -e .`
+
+## 快速上手
+### PDF 操作 
+#### 智能 PDF 文件转图片
+智能的把 PDF 文件里面的插图找出来，例如没有插图就将整页 PDF 截图下来，也能智能的将碎图拼接在一起
+
+##### Example:
+<pre># pdf_path 表示 PDF 文件的路径，输出 images 按页码进行汇总输出
+images = turnsole.pdf_to_images(pdf_path)</pre>
+
+### 图像操作工具箱 
+#### base64_to_bgr / bgr_to_base64
+图像和 base64 互相转换
+
+##### Example:
+<pre>image = turnsole.base64_to_bgr(img64)
+img64 = turnsole.bgr_to_base64(image)</pre>
+
+### image_crop
+根据 bbox 在 image 上进行切片，如果指定 perspective 为 True 则切片方式为透视变换（可以切旋转目标）
+
+##### Example:
+<pre>im_slice_no_perspective = turnsole.image_crop(image, bbox)
+im_slice = turnsole.image_crop(image, bbox, perspective=True)</pre>
+
+##### Output:
+
+<img src="docs/images/image_crop.png?raw=true" alt="image crop example" style="max-width: 200px;">
+
+### OCR 引擎模块 
+OCR 引擎指的是一系列跟 OCR 相关的底层模型，我们提供了这些模型的函数式调用接口和标准 API 
+
+- [x] ADC :tada:
+- [x] DBNet :tada:
+- [x] CRNN :tada:
+- [x] Object Detector :tada:
+- [x] Signature Detector :tada:
+
+#### 免费试用
+```python
+import requests
+
+results = requests.post(url=r'http://139.196.149.46:9001/gen_ocr', files={'file': open(file_path, 'rb')}).json()
+ocr_results = results['ocr_results']
+```
+
+#### Prerequisites
+由于 OCR 引擎模块依赖于底层神经网络模型，因此需要先用 Docker 挂载底层神经网络模型 
+
+首先把 ./model_repository 文件夹和里面的模型放到项目根目录下再启动，如果没有相关模型找 [lvkui](lvkui@situdata.com) 要 
+
+使用起来非常简单，你只需要启动对应的 Docker 容器即可
+
+```bash
+docker run --gpus="device=0" --rm -p 8000:8000 -p 8001:8001 -p 8002:8002 -v $PWD/model_repository:/models nvcr.io/nvidia/tritonserver:21.10-py3 tritonserver --model-repository=/models
+```
+
+#### ADC
+通用文件摆正算法
+
+``` 
+from turnsole.ocr_engine import angle_detector
+
+image_rotated, direction = angle_detector.ADC(image, fine_degree=False)
+```
+
+#### DBNet
+通用文字检测算法
+
+``` 
+from turnsole.ocr_engine import text_detector
+
+boxes = text_detector.predict(image)
+```
+
+#### CRNN
+通用文字识别算法
+
+``` 
+from turnsole.ocr_engine import text_recognizer
+
+ocr_result, ocr_time = text_recognizer.predict_batch(image, boxes)
+```
+
+#### Object Detector
+通用文件检测算法
+
+``` 
+from turnsole.ocr_engine import object_detector
+
+object_list = object_detector.process(image)
+```
+
+#### Signature Detector
+签字盖章二维码检测算法
+
+``` 
+from turnsole.ocr_engine import signature_detector
+
+signature_list = signature_detector.process(image)
+```
+
+#### 标准 API
+```
+python api/ocr_engine_server.py
+```
+

+LICENSE
+README.md
+setup.cfg
+setup.py
+turnsole/__init__.py
+turnsole/convenience.py
+turnsole/encodings.py
+turnsole/model.py
+turnsole/paths.py
+turnsole/pdf_tools.py
+turnsole.egg-info/PKG-INFO
+turnsole.egg-info/SOURCES.txt
+turnsole.egg-info/dependency_links.txt
+turnsole.egg-info/top_level.txt
+turnsole/face_utils/__init__.py
+turnsole/face_utils/agedetector.py
+turnsole/face_utils/facedetector.py
+turnsole/nets/__init__.py
+turnsole/nets/efficientnet.py
+turnsole/ocr_engine/__init__.py
+turnsole/ocr_engine/ADC/__init__.py
+turnsole/ocr_engine/ADC/angle_detector.py
+turnsole/ocr_engine/CRNN/__init__.py
+turnsole/ocr_engine/CRNN/alphabets.py
+turnsole/ocr_engine/CRNN/text_rec.py
+turnsole/ocr_engine/DBNet/__init__.py
+turnsole/ocr_engine/DBNet/text_detector.py
+turnsole/ocr_engine/object_det/__init__.py
+turnsole/ocr_engine/object_det/utils.py
+turnsole/ocr_engine/signature_det/__init__.py
+turnsole/ocr_engine/signature_det/utils.py
+turnsole/ocr_engine/utils/__init__.py
+turnsole/ocr_engine/utils/read_data.py
+turnsole/video/__init__.py
+turnsole/video/count_frames.py
+turnsole/video/filevideostream.py
+turnsole/video/fps.py
+turnsole/video/pivideostream.py
+turnsole/video/videostream.py
+turnsole/video/webcamvideostream.py
\ No newline at end of file

+

+turnsole

+try:
+    from . import ocr_engine
+except:
+    # print('[INFO] OCR engine can not import successful')
+    pass
+from .convenience import resize
+from .convenience import resize_with_pad
+from .convenience import image_crop
+from .encodings import bytes_to_bgr
+from .encodings import base64_to_image
+from .encodings import base64_encode_file
+from .encodings import base64_encode_image
+from .encodings import base64_decode_image
+from .encodings import base64_to_bgr
+from .encodings import bgr_to_base64
+from .pdf_tools import pdf_to_images
\ No newline at end of file

+import cv2
+import numpy as np
+
+def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
+    # initialize the dimensions of the image to be resized and grab the image size
+    dim = None
+    (h, w) = image.shape[:2]
+
+    # if both the width and height are None, then return the original image
+    if width is None and height is None:
+        return image
+
+    # check to see if the width is None
+    if width is None:
+        # calculate the ratio of the height and construct the dimensions
+        r = height / float(h)
+        dim = (int(w * r), height)
+
+    # otherwise, the height is None
+    else:
+        # calculate the ratio of the width and construct the dimensions
+        r = width / float(w)
+        dim = (width, int(h * r))
+
+    # resize the image
+    resized = cv2.resize(image, dim, interpolation=inter)
+
+    # return the resized image
+    return resized
+
+def resize_with_pad(image, target_width, target_height):
+    """Resuzes and pads an image to a target width and height.
+
+    Resizes an image to a target width and height by keeping the aspect ratio the same 
+    without distortion. 
+    ratio must be less than 1.0.
+    width and height will pad with zeroes.
+
+    Args:
+        image (Array): RGB/BGR
+        target_width (Int): Target width.
+        target_height (Int): Target height.
+
+    Returns:
+        Array: Resized and padded image. The image paded with zeroes.
+        Float: Image resized ratio. The ratio must be less than 1.0.
+    """
+    height, width, _ = image.shape
+
+    min_ratio = min(target_height/height, target_width/width)
+    ratio = min_ratio if min_ratio < 1.0 else 1.0
+
+    # To shrink an image, it will generally look best with INTER_AREA interpolation.
+    resized = cv2.resize(image, None, fx=ratio, fy=ratio, interpolation=cv2.INTER_AREA)
+    h, w, _ = resized.shape
+    canvas = np.zeros((target_height, target_width, 3), image.dtype)
+    canvas[:h, :w, :] = resized
+    return canvas, ratio
+
+def image_crop(image, bbox, perspective=False):
+    """根据 Bbox 在 image 上进行切片，如果指定 perspective 为 True 则切片方式为透视变换（可以切旋转目标）
+
+    Args:
+        image (array): 三通道图片，切片结果保持原图颜色通道
+        bbox (array/list): 支持两点矩形框和四点旋转矩形框
+            支持以下两种格式：
+            1. bbox = [xmin, ymin, xmax, ymax]
+            2. bbox = [x0, y0, x1, y1, x2, y2, x3, y3]
+        perspective (bool, optional): 是否切出旋转目标. Defaults to False.
+
+    Returns:
+        array: 小切图，和原图颜色通道一致
+    """
+    # 按照 bbox 的正外接矩形切图
+    bbox = np.array(bbox, dtype=np.int32).reshape((-1, 2))
+    xmin, ymin, xmax, ymax = [min(bbox[:, 0]),
+                              min(bbox[:, 1]), 
+                              max(bbox[:, 0]), 
+                              max(bbox[:, 1])]
+    xmin, ymin = max(0, xmin), max(0, ymin)
+    im_slice = image[ymin:ymax, xmin:xmax, :]
+
+    if perspective and bbox.shape[0] == 4:
+        # 获得旋转矩形的宽和高
+        w, h = [int(np.linalg.norm(bbox[0] - bbox[1])),
+                int(np.linalg.norm(bbox[3] - bbox[0]))]
+        # 把 bbox 平移到正切图的对应位置上
+        bbox[:, 0] -= xmin
+        bbox[:, 1] -= ymin
+        # 执行透视切图
+        pts1 = np.float32(bbox)
+        pts2 = np.float32([[0, 0], [w, 0], [w, h], [0, h]])
+        M = cv2.getPerspectiveTransform(pts1, pts2)
+        im_slice = cv2.warpPerspective(im_slice, M, (w, h))
+
+    return im_slice

+# -*- coding: utf-8 -*-
+# @Author        : Antonio-hi
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2021-08-09 19:08:49
+# @Last Modified : 2021-08-10 10:11:06
+# @Description   : 
+
+# import the necessary packages
+import numpy as np
+import base64
+import json
+import sys
+import cv2
+import os
+
+def base64_encode_image(a):
+    # return a JSON-encoded list of the base64 encoded image, image data type, and image shape
+    # return json.dumps([base64_encode_array(a), str(a.dtype), a.shape])
+    return json.dumps([base64_encode_array(a).decode("utf-8"), str(a.dtype),
+        a.shape])
+
+def base64_decode_image(a):
+    # grab the array, data type, and shape from the JSON-decoded object
+    (a, dtype, shape) = json.loads(a)
+
+    # set the correct data type and reshape the matrix into an image
+    a = base64_decode_array(a, dtype).reshape(shape)
+
+    # return the loaded image
+    return a
+
+def base64_encode_array(a):
+    # return the base64 encoded array
+    return base64.b64encode(a)
+
+def base64_decode_array(a, dtype):
+    # decode and return the array
+    return np.frombuffer(base64.b64decode(a), dtype=dtype)
+
+def base64_encode_file(image_path):
+    filename = os.path.basename(image_path)
+    # encode image file to base64 string
+    with open(image_path, 'rb') as f:
+        buffer = f.read()
+        # convert bytes buffer string then encode to base64 string
+        img64_bytes = base64.b64encode(buffer)
+        img64_str = img64_bytes.decode('utf-8')          # bytes to str
+    return json.dumps({"filename" : filename, "img64": img64_str})
+
+def base64_to_image(img64):
+    image_buffer = base64_decode_array(img64, dtype=np.uint8)
+    # In the case of color images, the decoded images will have the channels stored in B G R order.
+    image = cv2.imdecode(image_buffer, cv2.IMREAD_COLOR)
+    return image
+
+def bytes_to_bgr(buffer: bytes):
+    """Read a byte stream as a OpenCV image
+    
+    Args:
+        buffer (TYPE): bytes of a decoded image
+    """
+    img_array = np.frombuffer(buffer, np.uint8)
+    image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+    return image
+
+def base64_to_bgr(img64):
+    """把 base64 转换成图片
+        单通道的灰度图或四通道的透明图都将自动转换成三通道的 BGR 图
+    
+    Args:
+        img64 (TYPE): Description
+    
+    Returns:
+        TYPE: image is a 3-D uint8 Tensor of shape [height, width, channels] where channels is BGR
+    """
+    encoded_image = base64.b64decode(img64)
+    img_array = np.frombuffer(encoded_image, np.uint8)
+    image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+    return image
+
+def bgr_to_base64(image):
+    """ 把图片转换成 base64 格式，过程中把图片以 JPEG 格式进行了压缩，通常这会导致图像质量变差
+    
+    Args:
+        image (TYPE): image is a 3-D uint8 or uint16 Tensor of shape [height, width, channels] where channels is BGR
+    
+    Returns:
+        TYPE: base64 格式的图片
+    """
+    retval, encoded_image = cv2.imencode('.jpg', image)             # Encodes an image(BGR) into a memory buffer.
+    img64 = base64.b64encode(encoded_image)
+    return img64.decode('utf-8')
+
+
+if __name__ == '__main__':
+
+    image_path = '/home/lk/Repository/Project/turnsole/demos/images/sunflower.jpg'
+
+    # 1）将图片文件转换成 base64 base64编码的字符串(理论上支持任意文件)
+    json_str = base64_encode_file(image_path)
+
+    img64_dict = json.loads(json_str)
+
+    suffix = os.path.splitext(img64_dict['filename'])[-1].lower()
+    if suffix not in ['.jpg', '.jpeg', '.png', '.bmp']:
+        print(f'[INFO] 暂不支持格式为 {suffix} 的文件!')
+
+    # 2）将 base64 编码的字符串转成图片
+    image = base64_to_image(img64_dict['img64'])
+
+    inputs = image/255.
+
+    # 3）自创的, 将 array 转 base64 编码再转回array, 中间不经历图片操作, 还能保持 array 的数据类型
+    base64_encode_json_string = base64_encode_image(inputs)
+    
+    inputs = base64_decode_image(base64_encode_json_string)
+
+    print(inputs)
+
+    # 3、字符串前加 b
+    # 例: response = b'<h1>Hello World!</h1>'     # b' ' 表示这是一个 bytes 对象
+
+    # 作用：
+
+    # b" "前缀表示：后面字符串是bytes 类型。
+
+    # 用处：
+
+    # 网络编程中，服务器和浏览器只认bytes 类型数据。
+
+    # 如：send 函数的参数和 recv 函数的返回值都是 bytes 类型
+
+    # 附：
+
+    # 在 Python3 中，bytes 和 str 的互相转换方式是
+    # str.encode('utf-8')
+    # bytes.decode('utf-8')

+# -*- coding: utf-8 -*-
+# @Author        : lk
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2021-08-11 17:10:16
+# @Last Modified : 2021-08-12 16:14:53
+# @Description   : 
+
+import os
+import tensorflow as tf
+
+class AgeDetector:
+    def __init__(self, model_path):
+        self.age_map = {
+                        0: '0-2',
+                        1: '4-6',
+                        2: '8-13',
+                        3: '15-20',
+                        4: '25-32',
+                        5: '38-43',
+                        6: '48-53',
+                        7: '60+'
+                    }
+
+        self.model = tf.keras.models.load_model(filepath=model_path,
+                                                compile=False)
+        self.inference_model = self.build_inference_model()
+
+    def build_inference_model(self):
+        image = self.model.input
+        x = tf.keras.applications.mobilenet_v2.preprocess_input(image)
+        predictions = self.model(x, training=False)
+        inference_model = tf.keras.Model(inputs=image, outputs=predictions)
+        return inference_model
+
+    def predict_batch(self, images):
+        # 输入一个人脸图片列表,列表不应为空
+        images = tf.stack([tf.image.resize(image, [96, 96]) for image in images], axis=0)
+        preds = self.inference_model.predict(images)
+        indexes = tf.argmax(preds, axis=-1)
+        classes = [self.age_map[index.numpy()] for index in indexes]
+        return classes
+
+if __name__ == '__main__':
+
+    import cv2
+    from turnsole import paths
+
+    age_det = AGE_DETECTION(model_path='./ckpt/age_detector.h5')
+
+    data_dir = '/home/lk/Project/Face_Age_Gender/data/Emotion/emotion/010003_female_yellow_22'
+
+    for image_path in paths.list_images(data_dir):
+        image = cv2.imread(image_path)
+        classes = age_det.predict_batch([image])
+
+        print(classes)
+

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Created Date  : 2021-02-24 13:58:46
+# @Last Modified : 2021-03-05 18:14:17
+# @Description   :
+
+import tensorflow as tf
+
+from .nets.efficientnet import EfficientNetB0, EfficientNetB1, EfficientNetB2, EfficientNetB3
+from .nets.efficientnet import EfficientNetB4, EfficientNetB5, EfficientNetB6, EfficientNetB7
+
+def load_backbone(phi, input_tensor, weights='imagenet'):
+    if phi == 0:
+        model = EfficientNetB0(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        # 从这些层提取特征
+        layer_names = [
+            'block2b_add',   # 1/4
+            'block3b_add',   # 1/8
+            'block5c_add',   # 1/16
+            'block7a_project_bn',  # 1/32
+        ]
+    elif phi == 1:
+        model = EfficientNetB1(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2c_add',   # 1/4
+            'block3c_add',   # 1/8
+            'block5d_add',   # 1/16
+            'block7b_add',   # 1/32
+        ]
+    elif phi == 2:
+        model = EfficientNetB2(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2c_add',   # 1/4
+            'block3c_add',   # 1/8
+            'block5d_add',   # 1/16
+            'block7b_add',   # 1/32
+        ]
+    elif phi == 3:
+        model = EfficientNetB3(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2c_add',   # 1/4
+            'block3c_add',   # 1/8
+            'block5e_add',   # 1/16
+            'block7b_add',   # 1/32
+        ]
+    elif phi == 4:
+        model = EfficientNetB4(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2c_add',   # 1/4
+            'block3d_add',   # 1/8
+            'block5f_add',   # 1/16
+            'block7b_add',   # 1/32
+        ]
+    elif phi == 5:
+        model = EfficientNetB5(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2e_add',   # 1/4
+            'block3e_add',   # 1/8
+            'block5g_add',   # 1/16
+            'block7c_add',   # 1/32
+        ]
+    elif phi == 6:
+        model = EfficientNetB6(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2f_add',   # 1/4
+            'block3f_add',   # 1/8
+            'block5h_add',   # 1/16
+            'block7c_add',   # 1/32
+        ]
+    elif phi == 7:
+        model = EfficientNetB7(include_top=False,
+                               weights=weights,
+                               input_tensor=input_tensor)
+        layer_names = [
+            'block2g_add',   # 1/4
+            'block3g_add',   # 1/8
+            'block5j_add',   # 1/16
+            'block7d_add',   # 1/32
+        ]
+
+    skips = [model.get_layer(name).output for name in layer_names]
+    return model, skips
+
+def EasyDet(phi=0, input_size=(None, None, 3), weights='imagenet'):
+    image_input = tf.keras.layers.Input(shape=input_size)
+
+    backbone, skips = load_backbone(phi=phi, input_tensor=image_input, weights=weights)
+    C2, C3, C4, C5 = skips
+
+    in2 = tf.keras.layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in2')(C2)
+    in3 = tf.keras.layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in3')(C3)
+    in4 = tf.keras.layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in4')(C4)
+    in5 = tf.keras.layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in5')(C5)
+
+    # 1 / 32 * 8 = 1 / 4
+    P5 = tf.keras.layers.UpSampling2D(size=(8, 8))(
+        tf.keras.layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(in5))
+    # 1 / 16 * 4 = 1 / 4
+    out4 = tf.keras.layers.Add()([in4, tf.keras.layers.UpSampling2D(size=(2, 2))(in5)])
+    P4 = tf.keras.layers.UpSampling2D(size=(4, 4))(
+        tf.keras.layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(out4))
+    # 1 / 8 * 2 = 1 / 4
+    out3 = tf.keras.layers.Add()([in3, tf.keras.layers.UpSampling2D(size=(2, 2))(out4)])
+    P3 = tf.keras.layers.UpSampling2D(size=(2, 2))(
+        tf.keras.layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(out3))
+    # 1 / 4
+    P2 = tf.keras.layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(
+        tf.keras.layers.Add()([in2, tf.keras.layers.UpSampling2D(size=(2, 2))(out3)]))
+    # (b, 1/4, 1/4, 256)
+    fuse = tf.keras.layers.Concatenate()([P2, P3, P4, P5])
+
+    model = tf.keras.models.Model(inputs=image_input, outputs=fuse)
+    return model
+
+
+if __name__ == '__main__':
+    model = EasyDet(phi=0)
+    model.summary()
+
+    import time
+    import numpy as np
+
+    x = np.random.random_sample((1, 640, 640, 3))
+    # warm up
+    output = model.predict(x)
+
+    print('\n[INFO] Test start')
+    time_start = time.time()
+    for i in range(1000):
+        output = model.predict(x)
+        
+        time_end = time.time()
+        print('[INFO] Time used: {:.2f} ms'.format((time_end - time_start)*1000/(i+1)))

+from . import angle_detector
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : lk
+# @Email         : 9428.al@gmail.com
+# @Created Date  : 2019-09-03 15:40:54
+# @Last Modified : 2022-07-18 16:10:36
+# @Description   :
+
+import os
+import cv2
+import time
+import numpy as np
+# import tensorflow as tf
+
+# import grpc
+# from tensorflow_serving.apis import predict_pb2
+# from tensorflow_serving.apis import prediction_service_pb2_grpc
+
+import tritonclient.grpc as grpcclient
+
+
+def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
+    '''
+    Resize the input image according to the dimensions and keep aspect ratio of this image
+    '''
+    dim = None
+    (h, w) = image.shape[:2]
+
+    # if both the width and height are None, then return the original image
+    if width is None and height is None:
+        return image
+
+    # check to see if the width is None
+    if width is None:
+        # calculate the ratio of the height and construct the dimensions
+        r = height / float(h)
+        dim = (int(w * r), height)
+
+    # otherwise, the height is None
+    else:
+        # calculate the ratio of the width and construct the dimensions
+        r = width / float(w)
+        dim = (width, int(h * r))
+
+    # resize the image
+    resized = cv2.resize(image, dim, interpolation=inter)
+
+    return resized
+
+def predict(image):
+    
+    ROTATE = [0, 90, 180, 270]
+
+    # pre-process the image for classification
+    # Test 1: 直接resize到目标尺寸
+    # image = cv2.resize(image, (512, 512))
+    
+    # Test 2: 按照短边resize到目标尺寸,长边按比例缩放
+    short_side = 768
+    if min(image.shape[:2]) > short_side:
+        image = resize(image, width=short_side) if image.shape[0] > image.shape[1] else resize(image, height=short_side)
+    
+    # Test 3: 带padding的resize策略
+    # image = resize_image_with_pad(image, 1024, 1024)
+    
+    # Test 4: 直接使用原图
+    # image = image
+
+    image = np.array(image, dtype="float32")
+    image = 2 * (image / 255.0) - 1  # Let data input to be  normalized to the [-1,1] range
+    input_data = np.expand_dims(image, 0)
+
+    # options = [('grpc.max_send_message_length', 1000 * 1024 * 1024),
+    #            ('grpc.max_receive_message_length', 1000 * 1024 * 1024)]
+    # channel = grpc.insecure_channel('localhost:8500', options=options)
+    # stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
+
+    # request = predict_pb2.PredictRequest()
+    # request.model_spec.name = 'adc_model'
+    # request.model_spec.signature_name = 'serving_default'
+    # request.inputs['input_1'].CopyFrom(tf.make_tensor_proto(inputs))
+
+    # result = stub.Predict(request, 100.0)  # 100 secs timeout
+
+    # preds = tf.make_ndarray(result.outputs['dense'])
+
+    triton_client = grpcclient.InferenceServerClient("localhost:8001")
+
+    # Initialize the data
+    inputs = [grpcclient.InferInput('input_1', input_data.shape, "FP32")]               # [InferInput 类的一个对象用于描述推理请求的输入张量。]
+    inputs[0].set_data_from_numpy(input_data)                                       # 从指定的numpy数组中获取张量数据与此对象关联的输入
+    outputs = [grpcclient.InferRequestedOutput("dense")]
+
+    # Inference
+    results = triton_client.infer(
+        model_name="adc_model",
+        inputs=inputs,
+        outputs=outputs
+    )
+    # Get the output arrays from the results
+    preds = results.as_numpy("dense")
+    
+    index = np.argmax(preds, axis=-1)[0]
+
+    return index
+    # return ROTATE[index]
+
+def DegreeTrans(theta):
+    '''
+    Convert radians to angles
+    '''
+    res = theta / np.pi * 180
+    return res
+
+def rotateImage(src, degree):
+    '''
+    Calculate the rotation matrix and rotate the image
+    param src:image after rot90
+    param degree:the Hough degree
+    '''
+    h, w = src.shape[:2]
+    RotateMatrix = cv2.getRotationMatrix2D((w/2.0, h/2.0), degree, 1)
+    # affine transformation, background color fills white
+    rotate = cv2.warpAffine(src, RotateMatrix, (w, h), borderValue=(255, 255, 255))
+    return rotate
+
+def CalcDegree(srcImage):
+    '''
+    Calculating angles by Hough transform
+    param srcImage:image after rot90
+    '''
+    midImage = cv2.cvtColor(srcImage, cv2.COLOR_BGR2GRAY)
+    dstImage = cv2.Canny(midImage, 100, 300, 3)
+    lineimage = srcImage.copy()
+ 
+    # 通过霍夫变换检测直线
+    # 第4个参数(th)就是阈值，阈值越大，检测精度越高 
+    th = 500
+    while True:
+        if th > 0:
+            lines = cv2.HoughLines(dstImage, 1, np.pi/180, th)
+        else:
+            lines = None
+            break
+        if lines is not None:
+            if len(lines) > 10:
+                break
+            else:
+                th -=  50
+                # print ('阈值是：', th)
+        else:
+            th -= 100
+            # print ('阈值是：', th)
+        continue
+    
+    sum_theta = 0
+    num_theta = 0
+    if lines is not None:
+        for i in range(len(lines)):
+            for rho, theta in lines[i]:
+                # control the angle of line between -30 to +30
+                if theta > 1 and theta < 2.1:
+                    sum_theta += theta
+                    num_theta += 1
+    # Average all angles
+    if num_theta == 0:
+        average = np.pi/2
+    else:
+        average = sum_theta / num_theta
+
+    return DegreeTrans(average) - 90
+
+def ADC(image, fine_degree=False):
+    '''
+    return param rotate: Corrected image
+    return param angle_degree：image offset image
+    '''
+    
+    # Return a wide angle index
+    img = np.copy(image)
+    angle_index = predict(img)
+    img_rot = np.rot90(img, -angle_index)
+    
+    # if fine_degree then the image will be corrected more accurately based on character line features.
+    if fine_degree:
+        degree = CalcDegree(img_rot)
+        angle_degree = (angle_index * 90 - degree) % 360
+        rotate = rotateImage(img_rot, degree)
+        return rotate, angle_degree
+    
+    return img_rot, int(angle_index*90)

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-07-28 19:40:10
+# @Last Modified : 2022-09-08 18:00:40
+# @Description   : 
+
+from .text_rec import textRecServer
+
+text_recognizer = textRecServer()

+import cv2
+import time
+import numpy as np
+from .alphabets import alphabet
+import tritonclient.grpc as grpcclient
+
+
+def sort_poly(p):
+    # Find the minimum coordinate using (Xi+Yi)
+    min_axis = np.argmin(np.sum(p, axis=1))
+    # Sort the box coordinates
+    p = p[[min_axis, (min_axis + 1) % 4, (min_axis + 2) % 4, (min_axis + 3) % 4]]
+    if abs(p[0, 0] - p[1, 0]) > abs(p[0, 1] - p[1, 1]):
+        return p
+    else:
+        return p[[0, 3, 2, 1]]
+
+def client_init(url="localhost:8001",
+                ssl=False, private_key=None, root_certificates=None, certificate_chain=None,
+                verbose=False):
+    triton_client = grpcclient.InferenceServerClient(
+        url=url,
+        verbose=verbose,
+        ssl=ssl,
+        root_certificates=root_certificates,
+        private_key=private_key,
+        certificate_chain=certificate_chain)
+    return triton_client
+
+class textRecServer:
+    """_summary_
+    """
+    def __init__(self):
+        super().__init__()
+        self.charactersS = ' ' + alphabet
+        self.batchsize = 8
+
+        self.input_name = 'INPUT__0'
+        self.output_name = 'OUTPUT__0'
+        self.model_name = 'text_rec_torch'
+        self.np_type = np.float32
+        self.quant_type = "FP32"
+        self.compression_algorithm = None
+        self.outputs = []
+        self.outputs.append(grpcclient.InferRequestedOutput(self.output_name))
+
+    def preprocess_one_image(self, image):
+        _, w, _ = image.shape
+        image = self._transform(image, w)
+        return image
+
+    def predict_batch(self, im, boxes):
+        """Summary
+        
+        Args:
+            im (TYPE): RGB
+            boxes (TYPE): Description
+        
+        Returns:
+            TYPE: Description
+        """
+
+        triton_client = client_init("localhost:8001")
+        count_boxes = len(boxes)
+        boxes = sorted(boxes,
+                       key=lambda box: int(32.0 * (np.linalg.norm(box[0] - box[1])) / (np.linalg.norm(box[3] - box[0]))),
+                       reverse=True)
+    
+        results = {}
+        labels = []
+        rectime = 0.0
+        if len(boxes) != 0:
+            for i in range(len(boxes) // self.batchsize + int(len(boxes) % self.batchsize != 0)):
+                box = boxes[min(len(boxes)-1, i * self.batchsize)]
+                w, h = [int(np.linalg.norm(box[0] - box[1])), int(np.linalg.norm(box[3] - box[0]))]
+                width = max(32, min(int(32.0 * w / h), 960))
+                if width < 32:
+                    continue
+                slices = []
+                for index, box in enumerate(boxes[i * self.batchsize:(i + 1) * self.batchsize]):
+                    _box = [n for a in box for n in a]
+                    if i * self.batchsize + index < count_boxes:
+                        results[i * self.batchsize + index] = [list(map(int, _box))]
+                    w, h = [int(np.linalg.norm(box[0] - box[1])), int(np.linalg.norm(box[3] - box[0]))]
+                    pts1 = np.float32(box)
+                    pts2 = np.float32([[0, 0], [w, 0], [w, h], [0, h]])
+
+                    # 前处理优化
+                    xmin, ymin, _w, _h = cv2.boundingRect(pts1)
+                    xmax, ymax = xmin+_w, ymin+_h
+                    xmin, ymin = max(0, xmin), max(0, ymin)
+                    im_sclice = im[int(ymin):int(ymax), int(xmin):int(xmax), :]
+                    pts1[:, 0] -= xmin
+                    pts1[:, 1] -= ymin
+
+                    M = cv2.getPerspectiveTransform(pts1, pts2)
+                    im_crop = cv2.warpPerspective(im_sclice, M, (w, h))
+                    im_crop = self._transform(im_crop, width)
+                    slices.append(im_crop)
+                start_rec = time.time()
+                slices = self.np_type(slices)
+                slices = slices.transpose(0, 3, 1, 2)
+                slices = slices/127.5-1.
+                inputs = []
+                inputs.append(grpcclient.InferInput(self.input_name, list(slices.shape), self.quant_type))
+                inputs[0].set_data_from_numpy(slices)
+
+                # inference
+                preds = triton_client.infer(
+                    model_name=self.model_name,
+                    inputs=inputs,
+                    outputs=self.outputs,
+                    compression_algorithm=self.compression_algorithm
+                )
+                preds = preds.as_numpy(self.output_name).copy()
+                preds = preds.transpose(1, 0)
+                tmp_labels = self.decode(preds)
+                rectime += (time.time() - start_rec)
+                labels.extend(tmp_labels)
+
+            for index, label in enumerate(labels[:count_boxes]):
+                label = label.replace(' ', '').replace('￥', '¥')
+                if label == '':
+                    del results[index]
+                    continue
+                results[index].append(label)
+            # 重新排序
+            results = list(results.values())
+            results = sorted(results, key=lambda x: x[0][1], reverse=False) # 按 y0 从小到大排
+            keys = [str(i) for i in range(len(results))]
+            results = dict(zip(keys, results))
+        else:
+            results = dict()
+            rectime = -1
+        return results, rectime
+        
+    def decode(self, preds):
+        res = []
+        for t in preds:
+            length = len(t)
+            char_list = []
+            for i in range(length):
+                if t[i] != 0 and (not (i > 0 and t[i-1] == t[i])):
+                    char_list.append(self.charactersS[t[i]])
+            res.append(u''.join(char_list))
+        return res
+
+    def _transform(self, im, width):
+        height=32
+
+        ori_h, ori_w = im.shape[:2]
+        ratio1 = width * 1.0 / ori_w
+        ratio2 = height * 1.0 / ori_h
+        if ratio1 < ratio2:
+            ratio = ratio1
+        else:
+            ratio = ratio2
+        new_w, new_h = int(ori_w * ratio), int(ori_h * ratio)
+        if new_w<4:
+            new_w = 4
+        im = cv2.resize(im, (new_w, new_h))
+        img = np.ones((height, width, 3), dtype=np.uint8)*230
+        img[:im.shape[0], :im.shape[1], :] = im
+        return img

+from . import text_detector
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-06-01 19:00:18
+# @Last Modified : 2022-07-15 11:41:25
+# @Description   : 
+
+import os
+import cv2
+import time
+import pyclipper
+import numpy as np
+# import tensorflow as tf
+from shapely.geometry import Polygon
+
+# import grpc
+# from tensorflow_serving.apis import predict_pb2
+# from tensorflow_serving.apis import prediction_service_pb2_grpc
+
+import tritonclient.grpc as grpcclient
+
+
+def resize_with_padding(src, limit_max=1024):
+    '''限制长边不大于 limit_max 短边等比例缩放，以 0 填充'''
+    img = src.copy()
+
+    h, w, _ = img.shape
+    max_side = max(h, w)
+    ratio = limit_max / max_side if max_side > limit_max else 1
+    h, w = int(h * ratio), int(w * ratio)
+    proc = cv2.resize(img, (w, h))
+
+    canvas = np.zeros((limit_max, limit_max, 3), dtype=np.float32)
+    canvas[0:h, 0:w, :] = proc
+    return canvas, ratio
+
+def rectangle_boxes_zoom(boxes, offset=1):
+    '''Scale the rectangle boxes via offset
+    Input:
+        boxes: with shape (-1, 4, 2)
+        offset: how many pix do you wanna zoom, we recommend less than 5
+    Output:
+        boxes: zoomed
+    '''
+    boxes = np.array(boxes)
+    boxes += [[[-offset,-offset], [offset,-offset], [offset,offset], [-offset,offset]]]
+    return boxes
+
+def polygons_from_probmap(preds, ratio):
+    # 二值化
+    prob_map_pred = np.array(preds, dtype=np.uint8)[0,:,:,0]
+    # 输入：二值图、轮廓检索（层次）模式、轮廓渐进方法
+    # 输出：轮廓、层级关系
+    contours, hierarchy = cv2.findContours(prob_map_pred, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    boxes = []
+    for contour in contours:
+        if len(contour) < 4:
+            continue
+
+        # Vatti clipping 
+        polygon = Polygon(np.array(contour).reshape((-1, 2))).buffer(0)
+        polygon = polygon.convex_hull if polygon.type == 'MultiPolygon' else polygon                        # Note: 这里不是 bug 是我们故意而为之
+
+        if polygon.area < 10:
+            continue
+
+        distance = polygon.area * 1.5 / polygon.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(list(polygon.exterior.coords), pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        expanded = np.array(offset.Execute(distance)[0])                                                    # Note: 这里不是 bug 是我们故意而为之
+        
+        # Convert polygon to rectangle
+        rect = cv2.minAreaRect(expanded)
+        box = cv2.boxPoints(rect)
+        # make clock-wise order
+        box = np.roll(box, 4-box.sum(axis=1).argmin(), 0)
+        box = np.array(box/ratio, dtype=np.int32)
+        boxes.append(box)
+
+    return boxes
+
+def predict(image):
+
+    image_resized, ratio = resize_with_padding(image, limit_max=1280)
+    input_data = np.expand_dims(image_resized/255., axis=0)
+
+    # options = [('grpc.max_send_message_length', 1000 * 1024 * 1024),
+    #            ('grpc.max_receive_message_length', 1000 * 1024 * 1024)]
+    # channel = grpc.insecure_channel('localhost:8500', options=options)
+    # stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
+
+    # request = predict_pb2.PredictRequest()
+    # request.model_spec.name = 'dbnet_model'
+    # request.model_spec.signature_name = 'serving_default'
+    # request.inputs['input_1'].CopyFrom(tf.make_tensor_proto(inputs))
+
+    # result = stub.Predict(request, 100.0)  # 100 secs timeout
+
+    # preds = tf.make_ndarray(result.outputs['tf.math.greater'])
+
+    triton_client = grpcclient.InferenceServerClient("localhost:8001")
+
+    # Initialize the data
+    inputs = [grpcclient.InferInput('input_1', input_data.shape, "FP32")]
+    inputs[0].set_data_from_numpy(input_data)
+    outputs = [grpcclient.InferRequestedOutput("tf.math.greater")]
+
+    # Inference
+    results = triton_client.infer(
+        model_name="dbnet_model",
+        inputs=inputs,
+        outputs=outputs
+    )
+    # Get the output arrays from the results
+    preds = results.as_numpy("tf.math.greater")
+
+    boxes = polygons_from_probmap(preds, ratio)
+    #boxes = rectangle_boxes_zoom(boxes, offset=0)
+
+    return boxes

+# import the necessary packages
+from .ADC import angle_detector
+from .DBNet import text_detector
+from .CRNN import text_recognizer
+from .object_det import object_detector
+from .signature_det import signature_detector
\ No newline at end of file

+from .utils import ObjectDetection
+
+object_detector = ObjectDetection()
\ No newline at end of file

+# import grpc
+import turnsole
+import numpy as np
+# import tensorflow as tf
+# from tensorflow_serving.apis import predict_pb2, prediction_service_pb2_grpc
+
+import tritonclient.grpc as grpcclient
+
+
+class ObjectDetection():
+
+    """通用文件检测算法
+    输入图片输出检测结果
+
+    API 文档请参阅：
+    """
+
+    def __init__(self, confidence_threshold=0.5):
+        """初始化检测对象
+
+        Args:
+            confidence_threshold (float, optional): 目标检测模型的分类置信度
+        """
+
+        self.lable2index = {
+            'id_card_info':           0,
+            'id_card_guohui':         1,
+            'lssfz_front':            2,
+            'lssfz_back':             3,
+            'jzz_front':              4,
+            'jzz_back':               5,
+            'txz_front':              6,
+            'txz_back':               7,
+            'bank_card':              8,
+            'vehicle_license_front':  9,
+            'vehicle_license_back':  10,
+            'driving_license_front': 11,
+            'driving_license_back':  12,
+            'vrc_page_12':           13,
+            'vrc_page_34':           14,
+        }
+        self.index2lable = list(self.lable2index.keys())
+
+    # def resize_and_pad_to_384(self, image, jitter=True):
+    #     """长边在 256-384 之间随机取一个数，四边 pad 到 384
+
+    #     Args:
+    #         image (TYPE): An image represented as a numpy ndarray.
+    #     """
+    #     image_shape = tf.cast(tf.shape(image)[:2], dtype=tf.float32)
+    #     max_side = tf.random.uniform(
+    #         (), 256, 384, dtype=tf.float32) if jitter else 384.
+    #     ratio = max_side / tf.reduce_max(image_shape)
+    #     image_shape = tf.cast(ratio * image_shape, dtype=tf.int32)
+    #     image = tf.image.resize(image, image_shape)
+    #     image = tf.image.pad_to_bounding_box(image, 0, 0, 384, 384)
+    #     return image, ratio
+
+    def process(self, image):
+        """Processes an image and returns a list of the detected object location and classes data.
+
+        Args:
+            image (TYPE): An image represented as a numpy ndarray.
+        """
+        h, w, _ = image.shape
+        # image, ratio = self.resize_and_pad_to_384(image, jitter=False)
+        image, ratio = turnsole.resize_with_pad(image, target_height=384, target_width=384)
+        input_data = np.expand_dims(image/255., axis=0)
+
+        # options = [('grpc.max_send_message_length', 1000 * 1024 * 1024),
+        #            ('grpc.max_receive_message_length', 1000 * 1024 * 1024)]
+        # channel = grpc.insecure_channel('localhost:8500', options=options)
+        # stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
+
+        # request = predict_pb2.PredictRequest()
+        # request.model_spec.name = 'object_detection'
+        # request.model_spec.signature_name = 'serving_default'
+        # request.inputs['image'].CopyFrom(tf.make_tensor_proto(inputs, dtype='float32'))
+        # # 100 secs timeout
+        # result = stub.Predict(request, 100.0)
+
+        # # saved_model_cli show --dir saved_model/ --all                                         # 查看 saved model 的输入输出
+        # boxes = tf.make_ndarray(result.outputs['decode_predictions'])
+        # scores = tf.make_ndarray(result.outputs['decode_predictions_1'])
+        # classes = tf.make_ndarray(result.outputs['decode_predictions_2'])
+        # valid_detections = tf.make_ndarray(
+        #     result.outputs['decode_predictions_3'])
+
+        triton_client = grpcclient.InferenceServerClient("localhost:8001")
+
+        # Initialize the data
+        inputs = [grpcclient.InferInput('image', input_data.shape, "FP32")]
+        inputs[0].set_data_from_numpy(input_data.astype('float32'))
+        outputs = [
+                    grpcclient.InferRequestedOutput("decode_predictions"),
+                    grpcclient.InferRequestedOutput("decode_predictions_1"),
+                    grpcclient.InferRequestedOutput("decode_predictions_2"),
+                    grpcclient.InferRequestedOutput("decode_predictions_3")
+                    ]
+
+        # Inference
+        results = triton_client.infer(
+            model_name="object_detection",
+            inputs=inputs,
+            outputs=outputs
+        )
+        # Get the output arrays from the results
+        boxes = results.as_numpy("decode_predictions")
+        scores = results.as_numpy("decode_predictions_1")
+        classes = results.as_numpy("decode_predictions_2")
+        valid_detections = results.as_numpy("decode_predictions_3")
+
+        boxes = boxes[0][:valid_detections[0]]
+        scores = scores[0][:valid_detections[0]]
+        classes = classes[0][:valid_detections[0]]
+
+        object_list = []
+        for box, score, class_index in zip(boxes, scores, classes):
+            xmin, ymin, xmax, ymax = box / ratio
+            xmin = max(0, int(xmin))
+            ymin = max(0, int(ymin))
+            xmax = min(w, int(xmax))
+            ymax = min(h, int(ymax))
+            class_label = self.index2lable[int(class_index)]
+            item = {
+                "label": class_label,
+                "confidence": float(score),
+                "location": {
+                    "xmin": xmin,
+                    "ymin": ymin,
+                    "xmax": xmax,
+                    "ymax": ymax
+                }
+            }
+            object_list.append(item)
+
+        return object_list
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : lk
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-06-28 14:38:57
+# @Last Modified : 2022-09-06 14:37:47
+# @Description   : 
+
+from .utils import SignatureDetection
+
+signature_detector = SignatureDetection()
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : lk
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-02-08 14:10:00
+# @Last Modified : 2022-09-06 14:45:10
+# @Description   : 
+
+import turnsole
+import numpy as np
+# import tensorflow as tf
+
+# import grpc
+# from tensorflow_serving.apis import predict_pb2
+# from tensorflow_serving.apis import prediction_service_pb2_grpc
+
+import tritonclient.grpc as grpcclient
+
+
+# def resize_and_pad_to_1024(image, jitter=True):
+#     # 长边在 512-1024 之间随机取一个数，四边 pad 到 1024
+#     image_shape = tf.cast(tf.shape(image)[:2], dtype=tf.float32)
+#     max_side = tf.random.uniform((), 512, 1024, dtype=tf.float32) if jitter else 1024.
+#     ratio = max_side / tf.reduce_max(image_shape)
+#     image_shape = tf.cast(ratio * image_shape, dtype=tf.int32)
+#     image = tf.image.resize(image, image_shape)
+#     image = tf.image.pad_to_bounding_box(image, 0, 0, 1024, 1024)
+#     return image, ratio
+
+class SignatureDetection():
+
+    """签字盖章检测算法
+    输入图片输出检测结果
+
+    API 文档请参阅：
+    """
+
+    def __init__(self, confidence_threshold=0.5):
+        """初始化检测对象
+        
+        Args:
+            confidence_threshold (float, optional): 目标检测模型的分类置信度
+        """
+
+        self.lable2index = {
+                'circle':    0,
+                'ellipse':   1,
+                'rectangle': 2,
+                'signature': 3,
+                'qr_code':   4,
+                'bar_code':  5
+            }
+        self.index2lable = {
+                0: 'circle',
+                1: 'ellipse',
+                2: 'rectangle',
+                3: 'signature',
+                4: 'qr_code',
+                5: 'bar_code'
+            }
+
+
+    def process(self, image):
+        """Processes an image and returns a list of the detected signature location and classes data.
+        
+        Args:
+            image (TYPE): An image represented as a numpy ndarray.
+        """
+        h, w, _ = image.shape
+
+        # image, ratio = resize_and_pad_to_1024(image, jitter=False)
+        image, ratio = turnsole.resize_with_pad(image, target_height=1024, target_width=1024)
+        input_data = np.expand_dims(np.float32(image/255.), axis=0)
+
+        # options = [('grpc.max_send_message_length', 1000 * 1024 * 1024),
+        #            ('grpc.max_receive_message_length', 1000 * 1024 * 1024)]
+        # channel = grpc.insecure_channel('localhost:8500', options=options)
+        # stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
+
+        # request = predict_pb2.PredictRequest()
+        # request.model_spec.name = 'signature_model'
+        # request.model_spec.signature_name = 'serving_default'
+        # request.inputs['image'].CopyFrom(tf.make_tensor_proto(inputs, dtype='float32'))
+        # result = stub.Predict(request, 100.0)                                                   # 100 secs timeout
+
+        # # saved_model_cli show --dir saved_model/ --all         # 查看 saved model 的输入输出
+        # boxes = tf.make_ndarray(result.outputs['decode_predictions'])
+        # scores = tf.make_ndarray(result.outputs['decode_predictions_1'])
+        # classes = tf.make_ndarray(result.outputs['decode_predictions_2'])
+        # valid_detections = tf.make_ndarray(result.outputs['decode_predictions_3'])
+
+        triton_client = grpcclient.InferenceServerClient("localhost:8001")
+
+        # Initialize the data
+        inputs = [grpcclient.InferInput('image', input_data.shape, "FP32")]
+        inputs[0].set_data_from_numpy(input_data)
+        outputs = [
+                    grpcclient.InferRequestedOutput("decode_predictions"),
+                    grpcclient.InferRequestedOutput("decode_predictions_1"),
+                    grpcclient.InferRequestedOutput("decode_predictions_2"),
+                    grpcclient.InferRequestedOutput("decode_predictions_3")
+                    ]
+
+        # Inference
+        results = triton_client.infer(
+            model_name="signature_model",
+            inputs=inputs,
+            outputs=outputs
+        )
+        # Get the output arrays from the results
+        boxes = results.as_numpy("decode_predictions")
+        scores = results.as_numpy("decode_predictions_1")
+        classes = results.as_numpy("decode_predictions_2")
+        valid_detections = results.as_numpy("decode_predictions_3")
+        
+        boxes = boxes[0][:valid_detections[0]]
+        scores = scores[0][:valid_detections[0]]
+        classes = classes[0][:valid_detections[0]]
+
+        signature_list = []
+        for box, score, class_index in zip(boxes, scores, classes):
+            xmin, ymin, xmax, ymax = box / ratio
+            class_label = self.index2lable[class_index]
+            item = {
+                "label": class_label,
+                "confidence": float(score),
+                "location": {
+                    "xmin": max(0, int(xmin)),
+                    "ymin": max(0, int(ymin)),
+                    "xmax": min(w, int(xmax)),
+                    "ymax": min(h, int(ymax))
+                }
+            }
+            signature_list.append(item)
+
+        return signature_list

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-06-16 11:01:36
+# @Last Modified : 2022-07-15 10:57:06
+# @Description   : 
+
+from .read_data import base64_to_bgr
+from .read_data import bytes_to_bgr
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Create Date   : 2022-06-16 10:59:50
+# @Last Modified : 2022-08-03 14:59:15
+# @Description   : 
+
+import cv2
+import base64
+import numpy as np
+import tensorflow as tf
+
+
+def base64_to_bgr(img64):
+    """把 base64 转换成图片
+        单通道的灰度图或四通道的透明图都将自动转换成三通道的 BGR 图
+    
+    Args:
+        img64 (TYPE): Description
+    
+    Returns:
+        TYPE: image is a 3-D uint8 Tensor of shape [height, width, channels] where channels is BGR
+    """
+    encoded_image = base64.b64decode(img64)
+    img_array = np.frombuffer(encoded_image, np.uint8)
+    image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+    return image
+
+def bytes_to_bgr(buffer: bytes):
+    """Read a byte stream as a OpenCV image
+    
+    Args:
+        buffer (TYPE): bytes of a decoded image
+    """
+    img_array = np.frombuffer(buffer, np.uint8)
+    image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+
+    # image = tf.io.decode_image(buffer, channels=3)
+    # image = np.array(image)[...,::-1]
+    return image
\ No newline at end of file

+# -*- coding: utf-8 -*-
+# @Author        : Lyu Kui
+# @Email         : 9428.al@gmail.com
+# @Created Date  : 2021-03-04 17:50:09
+# @Last Modified : 2021-03-10 14:03:02
+# @Description   : 
+
+import os
+
+image_types = (".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff")
+
+
+def list_images(basePath, contains=None):
+    # return the set of files that are valid
+    return list_files(basePath, validExts=image_types, contains=contains)
+
+def list_files(basePath, validExts=None, contains=None):
+    # loop over the directory structure
+    for (rootDir, dirNames, filenames) in os.walk(basePath):
+        # loop over the filenames in the current directory
+        for filename in filenames:
+            # if the contains string is not none and the filename does not contain
+            # the supplied string, then ignore the file
+            if contains is not None and filename.find(contains) == -1:
+                continue
+
+            # determine the file extension of the current file
+            ext = filename[filename.rfind("."):].lower()
+
+            # check to see if the file is an image and should be processed
+            if validExts is None or ext.endswith(validExts):
+                # construct the path to the image and yield it
+                imagePath = os.path.join(rootDir, filename)
+                yield imagePath
+
+def get_filename(filePath):
+    basename = os.path.basename(filePath)
+    fname, fextension = os.path.splitext(basename)
+    return fname
\ No newline at end of file

+import cv2
+import fitz
+import numpy as np
+
+def pdf_to_images(pdf_path: str):
+    """PDF 转 OpenCV Image
+    
+    Args:
+        pdf_path (str): Description
+    
+    Returns:
+        TYPE: Description
+    """
+    images = []
+    doc = fitz.open(pdf_path)
+    # producer = doc.metadata.get('producer')
+
+    for pno in range(doc.page_count):
+        page = doc.load_page(pno)
+
+        all_texts = page.get_text().replace('\n', '').strip()
+        # 根据经验过滤掉特殊情况
+        all_texts = all_texts.strip('Click to buy NOW!PDF-XChangewww.docu-track.comClick to buy NOW!PDF-XChangewww.docu-track.com')
+        blocks = page.get_text("dict")["blocks"]
+        imgblocks = [b for b in blocks if b["type"] == 1]
+
+        page_images = []
+        # 如果一个字都没有，
+        if len(all_texts) == 0 and len(imgblocks) != 0:
+            # # 这些 producer 包含碎图，如果真的是碎图我们把碎图拼接一下
+            # if producer in ['Microsoft: Print To PDF',
+            #                 'GPL Ghostscript 8.71',
+            #                 'doPDF Ver 7.3 Build 398 (Windows 7 Business Edition (SP 1) - Version: 6.1.7601 (x64))',
+            #                 '福昕阅读器PDF打印机 版本 11.0.114.4386']:
+            patches = []
+            for imgblock in imgblocks:
+                contents = imgblock["image"]
+                img_array = np.frombuffer(contents, dtype=np.uint8)
+                image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+                patches.append(image)
+            try:
+                try:
+                    image = np.concatenate(patches, axis=0)
+                    page_images.append(image)
+                except:
+                    image = np.concatenate(patches, axis=1)
+                    page_images.append(image)
+            except:
+                # 当两张拼不到一块的时候我们可以认为他是两张图，如果超过两张那就不一定了
+                if len(patches) == 2:
+                    page_images = patches
+                else:
+                    pix = page.get_pixmap(dpi=350)
+                    contents = pix.tobytes(output="png")
+                    img_array = np.frombuffer(contents, dtype=np.uint8)
+                    image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+                    page_images.append(image)
+            # else:
+            #     for imgblock in imgblocks:
+            #         contents = imgblock["image"]
+            #         img_array = np.frombuffer(contents, dtype=np.uint8)
+            #         image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+            #         page_images.append(image)
+        else:
+            pix = page.get_pixmap(dpi=350)
+            contents = pix.tobytes(output="png")
+            img_array = np.frombuffer(contents, dtype=np.uint8)
+            image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+            page_images.append(image)
+        images.append(page_images)
+    return images
+

+# import the necessary packages
+from .count_frames import count_frames
+from .fps import FPS
+from .videostream import VideoStream
+from .webcamvideostream import WebcamVideoStream
+from .filevideostream import FileVideoStream
\ No newline at end of file

+# import the necessary packages
+# from ..convenience import is_cv3
+import cv2
+
+def count_frames(path, override=False):
+	# grab a pointer to the video file and initialize the total
+	# number of frames read
+	video = cv2.VideoCapture(path)
+	total = 0
+
+	# if the override flag is passed in, revert to the manual
+	# method of counting frames
+	if override:
+		total = count_frames_manual(video)
+
+	# otherwise, let's try the fast way first
+	else:
+		# lets try to determine the number of frames in a video
+		# via video properties; this method can be very buggy
+		# and might throw an error based on your OpenCV version
+		# or may fail entirely based on your which video codecs
+		# you have installed
+		try:
+			# # check if we are using OpenCV 3
+			# if is_cv3():
+			# 	total = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+
+			# # otherwise, we are using OpenCV 2.4
+			# else:
+			# 	total = int(video.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))
+
+			total = int(video.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))
+
+		# uh-oh, we got an error -- revert to counting manually
+		except:
+			total = count_frames_manual(video)
+
+	# release the video file pointer
+	video.release()
+
+	# return the total number of frames in the video
+	return total
+
+def count_frames_manual(video):
+	# initialize the total number of frames read
+	total = 0
+
+	# loop over the frames of the video
+	while True:
+		# grab the current frame
+		(grabbed, frame) = video.read()
+	 
+		# check to see if we have reached the end of the
+		# video
+		if not grabbed:
+			break
+
+		# increment the total number of frames read
+		total += 1
+
+	# return the total number of frames in the video file
+	return total
\ No newline at end of file

+# import the necessary packages
+from threading import Thread
+import sys
+import cv2
+import time
+
+# import the Queue class from Python 3
+if sys.version_info >= (3, 0):
+	from queue import Queue
+
+# otherwise, import the Queue class for Python 2.7
+else:
+	from Queue import Queue
+
+
+class FileVideoStream:
+	def __init__(self, path, transform=None, queue_size=128):
+		# initialize the file video stream along with the boolean
+		# used to indicate if the thread should be stopped or not
+		self.stream = cv2.VideoCapture(path)
+		self.stopped = False
+		self.transform = transform
+
+		# initialize the queue used to store frames read from
+		# the video file
+		self.Q = Queue(maxsize=queue_size)
+		# intialize thread
+		self.thread = Thread(target=self.update, args=())
+		self.thread.daemon = True
+
+	def start(self):
+		# start a thread to read frames from the file video stream
+		self.thread.start()
+		return self
+
+	def update(self):
+		# keep looping infinitely
+		while True:
+			# if the thread indicator variable is set, stop the
+			# thread
+			if self.stopped:
+				break
+
+			# otherwise, ensure the queue has room in it
+			if not self.Q.full():
+				# read the next frame from the file
+				(grabbed, frame) = self.stream.read()
+
+				# if the `grabbed` boolean is `False`, then we have
+				# reached the end of the video file
+				if not grabbed:
+					self.stopped = True
+					break
+					
+				# if there are transforms to be done, might as well
+				# do them on producer thread before handing back to
+				# consumer thread. ie. Usually the producer is so far
+				# ahead of consumer that we have time to spare.
+				#
+				# Python is not parallel but the transform operations
+				# are usually OpenCV native so release the GIL.
+				#
+				# Really just trying to avoid spinning up additional
+				# native threads and overheads of additional
+				# producer/consumer queues since this one was generally
+				# idle grabbing frames.
+				if self.transform:
+					frame = self.transform(frame)
+
+				# add the frame to the queue
+				self.Q.put(frame)
+			else:
+				time.sleep(0.1)  # Rest for 10ms, we have a full queue
+
+		self.stream.release()
+
+	def read(self):
+		# return next frame in the queue
+		return self.Q.get()
+
+	# Insufficient to have consumer use while(more()) which does
+	# not take into account if the producer has reached end of
+	# file stream.
+	def running(self):
+		return self.more() or not self.stopped
+
+	def more(self):
+		# return True if there are still frames in the queue. If stream is not stopped, try to wait a moment
+		tries = 0
+		while self.Q.qsize() == 0 and not self.stopped and tries < 5:
+			time.sleep(0.1)
+			tries += 1
+
+		return self.Q.qsize() > 0
+
+	def stop(self):
+		# indicate that the thread should be stopped
+		self.stopped = True
+		# wait until stream resources are released (producer thread might be still grabbing frame)
+		self.thread.join()

+# import the necessary packages
+import datetime
+
+class FPS:
+	def __init__(self):
+		# store the start time, end time, and total number of frames
+		# that were examined between the start and end intervals
+		self._start = None
+		self._end = None
+		self._numFrames = 0
+
+	def start(self):
+		# start the timer
+		self._start = datetime.datetime.now()
+		return self
+
+	def stop(self):
+		# stop the timer
+		self._end = datetime.datetime.now()
+
+	def update(self):
+		# increment the total number of frames examined during the
+		# start and end intervals
+		self._numFrames += 1
+
+	def elapsed(self):
+		# return the total number of seconds between the start and
+		# end interval
+		return (self._end - self._start).total_seconds()
+
+	def fps(self):
+		# compute the (approximate) frames per second
+		return self._numFrames / self.elapsed()
\ No newline at end of file

+# import the necessary packages
+from picamera.array import PiRGBArray
+from picamera import PiCamera
+from threading import Thread
+import cv2
+
+class PiVideoStream:
+	def __init__(self, resolution=(320, 240), framerate=32, **kwargs):
+		# initialize the camera
+		self.camera = PiCamera()
+
+		# set camera parameters
+		self.camera.resolution = resolution
+		self.camera.framerate = framerate
+
+		# set optional camera parameters (refer to PiCamera docs)
+		for (arg, value) in kwargs.items():
+			setattr(self.camera, arg, value)
+
+		# initialize the stream
+		self.rawCapture = PiRGBArray(self.camera, size=resolution)
+		self.stream = self.camera.capture_continuous(self.rawCapture,
+			format="bgr", use_video_port=True)
+
+		# initialize the frame and the variable used to indicate
+		# if the thread should be stopped
+		self.frame = None
+		self.stopped = False
+
+	def start(self):
+		# start the thread to read frames from the video stream
+		t = Thread(target=self.update, args=())
+		t.daemon = True
+		t.start()
+		return self
+
+	def update(self):
+		# keep looping infinitely until the thread is stopped
+		for f in self.stream:
+			# grab the frame from the stream and clear the stream in
+			# preparation for the next frame
+			self.frame = f.array
+			self.rawCapture.truncate(0)
+
+			# if the thread indicator variable is set, stop the thread
+			# and resource camera resources
+			if self.stopped:
+				self.stream.close()
+				self.rawCapture.close()
+				self.camera.close()
+				return
+
+	def read(self):
+		# return the frame most recently read
+		return self.frame
+
+	def stop(self):
+		# indicate that the thread should be stopped
+		self.stopped = True

+# import the necessary packages
+from .webcamvideostream import WebcamVideoStream
+
+class VideoStream:
+	def __init__(self, src=0, usePiCamera=False, resolution=(320, 240),
+		framerate=32, **kwargs):
+		# check to see if the picamera module should be used
+		if usePiCamera:
+			# only import the picamera packages unless we are
+			# explicity told to do so -- this helps remove the
+			# requirement of `picamera[array]` from desktops or
+			# laptops that still want to use the `imutils` package
+			from .pivideostream import PiVideoStream
+
+			# initialize the picamera stream and allow the camera
+			# sensor to warmup
+			self.stream = PiVideoStream(resolution=resolution,
+				framerate=framerate, **kwargs)
+
+		# otherwise, we are using OpenCV so initialize the webcam
+		# stream
+		else:
+			self.stream = WebcamVideoStream(src=src)
+
+	def start(self):
+		# start the threaded video stream
+		return self.stream.start()
+
+	def update(self):
+		# grab the next frame from the stream
+		self.stream.update()
+
+	def read(self):
+		# return the current frame
+		return self.stream.read()
+
+	def stop(self):
+		# stop the thread and release any resources
+		self.stream.stop()

+# import the necessary packages
+from threading import Thread
+import cv2
+
+class WebcamVideoStream:
+	def __init__(self, src=0, name="WebcamVideoStream"):
+		# initialize the video camera stream and read the first frame
+		# from the stream
+		self.stream = cv2.VideoCapture(src)
+		(self.grabbed, self.frame) = self.stream.read()
+
+		# initialize the thread name
+		self.name = name
+
+		# initialize the variable used to indicate if the thread should
+		# be stopped
+		self.stopped = False
+
+	def start(self):
+		# start the thread to read frames from the video stream
+		t = Thread(target=self.update, name=self.name, args=())
+		t.daemon = True
+		t.start()
+		return self
+
+	def update(self):
+		# keep looping infinitely until the thread is stopped
+		while True:
+			# if the thread indicator variable is set, stop the thread
+			if self.stopped:
+				return
+
+			# otherwise, read the next frame from the stream
+			(self.grabbed, self.frame) = self.stream.read()
+
+	def read(self):
+		# return the frame most recently read
+		return self.frame
+
+	def stop(self):
+		# indicate that the thread should be stopped
+		self.stopped = True