Create reading_order.py

reading_order.py

@@ -0,0 +1,106 @@
+import numpy as np
+
+class OrderPolygons:
+    def __init__(self, text_direction = 'lr'):
+        self.text_direction = text_direction
+
+    # Defines whether two lines overlap vertically
+    def _y_overlaps(self, u, v):
+        #u_y_min < v_y_max and u_y_max > v_y_min
+        return u[3] < v[2] and u[2] > v[3]
+    
+    # Defines whether two lines overlap horizontally
+    def _x_overlaps(self, u, v):
+        #u_x_min < v_x_max and u_x_max > v_x_min
+        return u[1] < v[0] and u[0] > v[1]
+    
+    # Defines whether one line (u) is above the other (v)
+    def _above(self, u, v):
+        #u_y_min < v_y_min
+        return u[3] < v[3]
+
+    # Defines whether one line (u) is left of the other (v)
+    def _left_of(self, u, v):
+        #u_x_max < v_x_min
+        return u[0] < v[1]  
+    
+    # Defines whether one line (w) overlaps with two others (u,v)
+    def _separates(self, w, u, v):
+        if w == u or w == v:
+            return 0
+        #w_y_max < (min(u_y_min, v_y_min))
+        if w[2] < min(u[3], v[3]):
+            return 0
+        #w_y_min > max(u_y_max, v_y_max)
+        if w[3] > max(u[2], v[2]):
+            return 0
+        #w_x_min < u_x_max and w_x_max > v_x_min
+        if w[1] < u[0] and w[0] > v[1]:
+            return 1
+        return 0
+
+    # Slightly modified version of the Kraken implementation at
+    # https://github.com/mittagessen/kraken/blob/master/kraken/lib/segmentation.py
+    def reading_order(self, lines):
+        """Given the list of lines, computes
+        the partial reading order.  The output is a binary 2D array
+        such that order[i,j] is true if line i comes before line j
+        in reading order."""
+        # Input lines are arrays with 4 polygon coordinates:
+        # 0=x_right/x_max, 1=x_left/x_min, 2=y_down/y_max, 3=y_up/y_min
+        
+        # Array where the order of precedence between the lines is defined
+        order = np.zeros((len(lines), len(lines)), 'B')
+
+        # Defines reading direction: default is from left to right
+        if self.text_direction == 'rl':
+            def horizontal_order(u, v):
+                return not self._left_of(u, v)
+        else:
+            horizontal_order = self._left_of
+
+        for i, u in enumerate(lines):
+            for j, v in enumerate(lines):
+                if self._x_overlaps(u, v):
+                    if self._above(u, v):
+                        # line u is placed before line v in reading order
+                        order[i, j] = 1
+                else:
+                        
+                    if [w for w in lines if self._separates(w, u, v)] == []:
+                        if horizontal_order(u, v):
+                            order[i, j] = 1
+                    elif self._y_overlaps(u, v) and horizontal_order(u, v):
+                        order[i, j] = 1
+                    
+        return order
+    
+    # Taken from the Kraken implementation at 
+    # https://github.com/mittagessen/kraken/blob/master/kraken/lib/segmentation.py
+    def topsort(self, order):
+        """Given a binary array defining a partial order (o[i,j]==True means i<j),
+        compute a topological sort.  This is a quick and dirty implementation
+        that works for up to a few thousand elements."""
+
+        n = len(order)
+        visited = np.zeros(n)
+        L = []
+
+        def _visit(k):
+            if visited[k]:
+                return
+            visited[k] = 1
+            a, = np.nonzero(np.ravel(order[:, k]))
+            for line in a:
+                _visit(line)
+            L.append(k)
+
+        for k in range(n):
+            _visit(k)
+        return L
+
+    def order(self, lines):
+        order = self.reading_order(lines)
+        sorted = self.topsort(order)
+
+        return sorted