文本检测提取

.gitignore

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# vim swapfile
+*.swp
+
+# result files for demo
+static/results

data_util.py

+'''
+this file is modified from keras implemention of data process multi-threading,
+see https://github.com/fchollet/keras/blob/master/keras/utils/data_utils.py
+'''
+import time
+import numpy as np
+import threading
+import multiprocessing
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+
+
+class GeneratorEnqueuer():
+    """Builds a queue out of a data generator.
+
+    Used in `fit_generator`, `evaluate_generator`, `predict_generator`.
+
+    # Arguments
+        generator: a generator function which endlessly yields data
+        use_multiprocessing: use multiprocessing if True, otherwise threading
+        wait_time: time to sleep in-between calls to `put()`
+        random_seed: Initial seed for workers,
+            will be incremented by one for each workers.
+    """
+
+    def __init__(self, generator,
+                 use_multiprocessing=False,
+                 wait_time=0.05,
+                 random_seed=None):
+        self.wait_time = wait_time
+        self._generator = generator
+        self._use_multiprocessing = use_multiprocessing
+        self._threads = []
+        self._stop_event = None
+        self.queue = None
+        self.random_seed = random_seed
+
+    def start(self, workers=1, max_queue_size=10):
+        """Kicks off threads which add data from the generator into the queue.
+
+        # Arguments
+            workers: number of worker threads
+            max_queue_size: queue size
+                (when full, threads could block on `put()`)
+        """
+
+        def data_generator_task():
+            while not self._stop_event.is_set():
+                try:
+                    if self._use_multiprocessing or self.queue.qsize() < max_queue_size:
+                        generator_output = next(self._generator)
+                        self.queue.put(generator_output)
+                    else:
+                        time.sleep(self.wait_time)
+                except Exception:
+                    self._stop_event.set()
+                    raise
+
+        try:
+            if self._use_multiprocessing:
+                self.queue = multiprocessing.Queue(maxsize=max_queue_size)
+                self._stop_event = multiprocessing.Event()
+            else:
+                self.queue = queue.Queue()
+                self._stop_event = threading.Event()
+
+            for _ in range(workers):
+                if self._use_multiprocessing:
+                    # Reset random seed else all children processes
+                    # share the same seed
+                    np.random.seed(self.random_seed)
+                    thread = multiprocessing.Process(target=data_generator_task)
+                    thread.daemon = True
+                    if self.random_seed is not None:
+                        self.random_seed += 1
+                else:
+                    thread = threading.Thread(target=data_generator_task)
+                self._threads.append(thread)
+                thread.start()
+        except:
+            self.stop()
+            raise
+
+    def is_running(self):
+        return self._stop_event is not None and not self._stop_event.is_set()
+
+    def stop(self, timeout=None):
+        """Stops running threads and wait for them to exit, if necessary.
+
+        Should be called by the same thread which called `start()`.
+
+        # Arguments
+            timeout: maximum time to wait on `thread.join()`.
+        """
+        if self.is_running():
+            self._stop_event.set()
+
+        for thread in self._threads:
+            if thread.is_alive():
+                if self._use_multiprocessing:
+                    thread.terminate()
+                else:
+                    thread.join(timeout)
+
+        if self._use_multiprocessing:
+            if self.queue is not None:
+                self.queue.close()
+
+        self._threads = []
+        self._stop_event = None
+        self.queue = None
+
+    def get(self):
+        """Creates a generator to extract data from the queue.
+
+        Skip the data if it is `None`.
+
+        # Returns
+            A generator
+        """
+        while self.is_running():
+            if not self.queue.empty():
+                inputs = self.queue.get()
+                if inputs is not None:
+                    yield inputs
+            else:
+                time.sleep(self.wait_time)
\ No newline at end of file

deploy.sh

+#!/bin/bash
+mkdir -p server_log
+gunicorn -w 3 run_demo_server:app -b 0.0.0.0:8769 -t 120 \
+	--error-logfile server_log/error.log \
+	--access-logfile server_log/access.log

dic2lyst_boundExpand.py

+def Dic2lyst(dic):
+    lystx=[]
+    lysty=[]
+    lst_value=list(dic.values())             
+    for i in range(0,7,2):
+        lystx.append(lst_value[i])
+    for i in range(1,8,2):
+        lysty.append(lst_value[i])
+    #print(lystx)
+    #print(lysty)        
+    lyst=[min(lystx),min(lysty),max(lystx),max(lysty)]        #将坐标的字典转化为矩形框四点坐标
+    x_size=lyst[2]-lyst[0]
+    lyst[0]-=x_size*0.1
+    lyst[2]+=x_size*0.1                 #边界扩宽
+    return lyst
+
+lyst={ "x0": 662, "y0": 551, "x1": 1010, "y1": 545, "x2": 1010, "y2": 561, "x3": 662, "y3": 567, "score": 0.2729945127192481 }
+lyst=Dic2lyst(lyst)
+#print(lyst)
+
+    
+def OrderDict(dic) :
+    import collections
+    #dic={ "x0": 662, "y0": 551, "x1": 1010, "y1": 545, "x2": 1010, "y2": 561, "x3": 662, "y3": 567, "score": 0.2729945127192481 }
+    dic1 = collections.OrderedDict()
+    dic1["x0"] = dic["x0"]
+    dic1["y0"] = dic["y0"]
+    dic1["x1"] = dic["x1"]
+    dic1["y1"] = dic["y1"]
+    dic1["x2"] = dic["x2"]
+    dic1["y2"] = dic["y2"]
+    dic1["x3"] = dic["x3"]
+    dic1["y3"] = dic["y3"]             #字典有序转化为无序
+    #print(dic1)
+    return dic1
+    #print(lst_value)
\ No newline at end of file

eval.py

+import cv2
+import time
+import math
+import os
+import numpy as np
+import tensorflow as tf
+
+import locality_aware_nms as nms_locality
+import lanms
+
+tf.app.flags.DEFINE_string('test_data_path', '/tmp/ch4_test_images/images/', '')
+tf.app.flags.DEFINE_string('gpu_list', '0', '')
+tf.app.flags.DEFINE_string('checkpoint_path', '/tmp/east_icdar2015_resnet_v1_50_rbox/', '')
+tf.app.flags.DEFINE_string('output_dir', '/tmp/ch4_test_images/images/', '')
+tf.app.flags.DEFINE_bool('no_write_images', False, 'do not write images')
+
+import model
+from icdar import restore_rectangle
+
+FLAGS = tf.app.flags.FLAGS
+
+def get_images():
+    '''
+    find image files in test data path
+    :return: list of files found
+    '''
+    files = []
+    exts = ['jpg', 'png', 'jpeg', 'JPG']
+    for parent, dirnames, filenames in os.walk(FLAGS.test_data_path):
+        for filename in filenames:
+            for ext in exts:
+                if filename.endswith(ext):
+                    files.append(os.path.join(parent, filename))
+                    break
+    print('Find {} images'.format(len(files)))
+    return files
+
+
+def resize_image(im, max_side_len=2400):
+    '''
+    resize image to a size multiple of 32 which is required by the network
+    :param im: the resized image
+    :param max_side_len: limit of max image size to avoid out of memory in gpu
+    :return: the resized image and the resize ratio
+    '''
+    h, w, _ = im.shape
+
+    resize_w = w
+    resize_h = h
+
+    # limit the max side
+    if max(resize_h, resize_w) > max_side_len:
+        ratio = float(max_side_len) / resize_h if resize_h > resize_w else float(max_side_len) / resize_w
+    else:
+        ratio = 1.
+    resize_h = int(resize_h * ratio)
+    resize_w = int(resize_w * ratio)
+
+    resize_h = resize_h if resize_h % 32 == 0 else (resize_h // 32 - 1) * 32
+    resize_w = resize_w if resize_w % 32 == 0 else (resize_w // 32 - 1) * 32
+    resize_h = max(32, resize_h)
+    resize_w = max(32, resize_w)
+    im = cv2.resize(im, (int(resize_w), int(resize_h)))
+
+    ratio_h = resize_h / float(h)
+    ratio_w = resize_w / float(w)
+
+    return im, (ratio_h, ratio_w)
+
+
+def detect(score_map, geo_map, timer, score_map_thresh=0.8, box_thresh=0.1, nms_thres=0.2):
+    '''
+    restore text boxes from score map and geo map
+    :param score_map:
+    :param geo_map:
+    :param timer:
+    :param score_map_thresh: threshhold for score map
+    :param box_thresh: threshhold for boxes
+    :param nms_thres: threshold for nms
+    :return:
+    '''
+    if len(score_map.shape) == 4:
+        score_map = score_map[0, :, :, 0]
+        geo_map = geo_map[0, :, :, ]
+    # filter the score map
+    xy_text = np.argwhere(score_map > score_map_thresh)
+    # sort the text boxes via the y axis
+    xy_text = xy_text[np.argsort(xy_text[:, 0])]
+    # restore
+    start = time.time()
+    text_box_restored = restore_rectangle(xy_text[:, ::-1]*4, geo_map[xy_text[:, 0], xy_text[:, 1], :]) # N*4*2
+    print('{} text boxes before nms'.format(text_box_restored.shape[0]))
+    boxes = np.zeros((text_box_restored.shape[0], 9), dtype=np.float32)
+    boxes[:, :8] = text_box_restored.reshape((-1, 8))
+    boxes[:, 8] = score_map[xy_text[:, 0], xy_text[:, 1]]
+    timer['restore'] = time.time() - start
+    # nms part
+    start = time.time()
+    boxes = nms_locality.nms_locality(boxes.astype(np.float64), 0.4)
+    #boxes = lanms.merge_quadrangle_n9(boxes.astype('float32'), nms_thres)
+    timer['nms'] = time.time() - start
+
+    if boxes.shape[0] == 0:
+        return None, timer
+
+    # here we filter some low score boxes by the average score map, this is different from the orginal paper
+    for i, box in enumerate(boxes):
+        mask = np.zeros_like(score_map, dtype=np.uint8)
+        cv2.fillPoly(mask, box[:8].reshape((-1, 4, 2)).astype(np.int32) // 4, 1)
+        boxes[i, 8] = cv2.mean(score_map, mask)[0]
+    boxes = boxes[boxes[:, 8] > box_thresh]
+    #from nms import non_max_suppression
+    #print(boxes)
+    #boxes=non_max_suppression(boxes, probs=None, overlapThresh=0.3)
+
+    return boxes, timer
+
+
+def sort_poly(p):
+    min_axis = np.argmin(np.sum(p, axis=1))
+    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 main(argv=None):
+    import os
+    os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_list
+
+
+    try:
+        os.makedirs(FLAGS.output_dir)
+    except OSError as e:
+        if e.errno != 17:
+            raise
+
+    with tf.get_default_graph().as_default():
+        input_images = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_images')
+        global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False)
+
+        f_score, f_geometry = model.model(input_images, is_training=False)
+
+        variable_averages = tf.train.ExponentialMovingAverage(0.997, global_step)
+        saver = tf.train.Saver(variable_averages.variables_to_restore())
+
+        with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
+            ckpt_state = tf.train.get_checkpoint_state(FLAGS.checkpoint_path)
+            model_path = os.path.join(FLAGS.checkpoint_path, os.path.basename(ckpt_state.model_checkpoint_path))
+            print('Restore from {}'.format(model_path))
+            saver.restore(sess, model_path)
+
+            im_fn_list = get_images()
+            for im_fn in im_fn_list:
+                im = cv2.imread(im_fn)[:, :, ::-1]
+                start_time = time.time()
+                im_resized, (ratio_h, ratio_w) = resize_image(im)
+
+                timer = {'net': 0, 'restore': 0, 'nms': 0}
+                start = time.time()
+                score, geometry = sess.run([f_score, f_geometry], feed_dict={input_images: [im_resized]})
+                timer['net'] = time.time() - start
+
+                boxes, timer = detect(score_map=score, geo_map=geometry, timer=timer)
+                print('{} : net {:.0f}ms, restore {:.0f}ms, nms {:.0f}ms'.format(
+                    im_fn, timer['net']*1000, timer['restore']*1000, timer['nms']*1000))
+
+                if boxes is not None:
+                    boxes = boxes[:, :8].reshape((-1, 4, 2))
+                    boxes[:, :, 0] /= ratio_w
+                    boxes[:, :, 1] /= ratio_h
+
+                duration = time.time() - start_time
+                print('[timing] {}'.format(duration))
+
+                # save to file
+                if boxes is not None:
+                    res_file = os.path.join(
+                        FLAGS.output_dir,
+                        '{}.txt'.format(
+                            os.path.basename(im_fn).split('.')[0]))
+                
+                    with open(res_file, 'w') as f:
+                        for box in boxes:
+                            # to avoid submitting errors
+                            box = sort_poly(box.astype(np.int32))
+                            if np.linalg.norm(box[0] - box[1]) < 5 or np.linalg.norm(box[3]-box[0]) < 5:
+                                continue
+                            f.write('{},{},{},{},{},{},{},{}\r\n'.format(
+                                box[0, 0], box[0, 1], box[1, 0], box[1, 1], box[2, 0], box[2, 1], box[3, 0], box[3, 1],
+                            ))
+                            cv2.polylines(im[:, :, ::-1], [box.astype(np.int32).reshape((-1, 1, 2))], True, color=(255, 255, 0), thickness=1)
+                if not FLAGS.no_write_images:
+                    img_path = os.path.join(FLAGS.output_dir, os.path.basename(im_fn))
+                    cv2.imwrite(img_path, im[:, :, ::-1])
+'''
+if __name__ == '__main__':
+    tf.app.run()