from typing import Sequence, Sequence, Union import warnings import numpy as np from numpy.typing import * import cv2 from sklearn.cluster import KMeans def dist(p1: NDArray, p2: NDArray): """Compute Euclid distance between p1 and p2. Args: p1(NDArray) and p2(NDArray) have same shape (..., k). """ return np.sqrt(np.sum((p1-p2)**2, axis=-1)) def norm(p: NDArray): """Perform L2-normalization on the given array. This function normalizes the input array `p` using the L2 norm, also known as the Euclidean norm. The L2 norm is calculated as the square root of the sum of the squared elements of `p`. The normalization process scales the elements of `p` so that the length of the resultant vector is 1. This is commonly used in machine learning and statistics to normalize the input features or data points. Parameters: p (NDArray): A numpy array of any shape, where the normalization is applied along the last dimension. Returns: NDArray: The L2-normalized array, having the same shape as the input array `p`. Example: >>> import numpy as np >>> p = np.array([[1, 2, 3], [4, 5, 6]]) >>> norm(p) array([[0.26726124, 0.53452248, 0.80178373], [0.45584231, 0.56980288, 0.68376346]]) Note: The function assumes that the input array `p` is not the zero vector, as the L2 norm of a zero vector is undefined. """ return p / (np.sqrt(np.sum(p ** 2, axis=-1))) def section_iou(l1: NDArray, l2:NDArray): """ Calculate the Intersection over Union (IoU) of two one-dimensional sections. Each sections contains k points, but only edge points are contributed. This function computes the IoU of two line segments, l1 and l2. Each segment is represented by a series of points. The IoU is calculated as the length of the intersection of the two segments divided by the length of their union. The segments are defined in an unordered manner, meaning that for each segment, the start and end points are not necessarily in increasing order. Args: l1 (NDArray): An array representing the first segment, shape (k, ). l2 (NDArray): An array representing the second segment, shape (k, ). Returns: float: The IoU of the two segments. The value ranges from 0 (no overlap) to 1 (full overlap). Example: >>> import numpy as np >>> l1 = np.array([1, 3, 2]) >>> l2 = np.array([2, 4, 3]) >>> section_iou(l1, l2) 0.3333333333333333 Note: The function includes a small constant (1e-4) in the denominator to avoid division by zero in case the union of the segments has zero length. """ less = (np.min(l1), np.min(l2)) greater = (np.max(l1), np.max(l2)) _iou = max(0, (np.min(greater) - np.max(less)) / (np.max(greater) - np.min(less) + 1e-4)) return _iou def uniform_curve_sampling(curve: NDArray, points: int): """Uniformly sample a specified number of points on a given curve. This function takes a curve represented by a series of points and samples a fixed number of points from it in a uniform manner, based on the cumulative length of the curve. It guarantees that the starting and ending points of the curve are included in the sampled points. Args: curve (NDArray): A numpy array representing the curve. The array should have the shape (k, 2), where k is the number of points in the curve and each point is a 2D coordinate (x, y). points (int): The number of points to sample from the curve. Returns: NDArray: A numpy array of the uniformly sampled points with the shape (p, 2), where p is equal to the 'points' argument. The function works by first calculating the length of each segment of the curve, then accumulating these lengths to find the total length of the curve. It then determines the positions along the curve where the uniformly spaced points should be, and interpolates these points based on the nearest segments in the original curve. """ k = curve.shape[0] # points in original curve segment_length = dist(curve, np.concatenate([curve[0:1], curve[:-1]], axis=0)) # (k, ) accumulate_length = np.cumsum(segment_length) # (k, ) curve_length = accumulate_length[-1] sample_results = np.zeros((points, 2)) sample_results[0] = curve[0] for p in range(1, points): curr_length = curve_length * p / (points - 1) # default return value v in (a(i-1), a(i)] curr_segment = np.searchsorted(accumulate_length, curr_length) curr_segment = min(k-1, curr_segment) # precision problem in division may ocurr theta = (accumulate_length[curr_segment] - curr_length) / segment_length[curr_segment] sample_results[p] = theta * curve[curr_segment-1] + (1-theta) * curve[curr_segment] return sample_results def extra_sampling(array: NDArray, extra_points: int): """Doing extra sampling to `array`, sample `extra_points` uniformly on each side. Args: arrray(NDArray): supporting two-dim array. """ result = [] # sample each pair of neighboring elements for i in range(len(array) - 1): samples = np.linspace(array[i], array[i + 1], extra_points + 1, endpoint=False)[1:] result.extend(samples) # adding last element result.append(array[-1]) return np.array(result) def compute_text_direction(polygon: NDArray): """Return normalized direction vector of a text region. Direction vector is along the positive Y-axis. """ vec1 = polygon[len(polygon)//2-1] - polygon[0] vec1 = vec1 if vec1[1] >= 0 else -vec1 vec2 = polygon[len(polygon)//2] - polygon[-1] vec2 = vec2 if vec2[1] >= 0 else -vec2 mean = (vec1 + vec2) / 2 return norm(mean) def find_top_bottom(polygon: NDArray): """Receive reordered polygon, find its top and bottom. Returns: in top-bottom order """ line0 = np.array([polygon[0], polygon[-1]]) line1 = np.array(polygon[len(polygon)//2-1:len(polygon)//2+1]) if np.mean(line0[:, 1]) < np.mean(line1[:, 1]): return line0, line1 else: return line1, line0 class ImageToolkits: """ImageToolkits class can achieve the following functionalities: 1. Separate single-line body text and double-line annotations in historical document images, and output corresponding JSON annotations. 2. Rectify the polygon representation of text lines, where the first n points correspond to one long edge, the last n points correspond to the opposite long edge, and the two long edges are joined end-to-end. 3. Calculate the aspect ratio of text lines (defined as the ratio of the long edge to the short edge). 4. Calculate the vertical aspect ratio of text lines in historical documents (defined as the ratio of the vertical edge to the horizontal edge). 5. Calculate the text center line(compared to the text kernel, there is no shrinkage along text direction). 6. Check the text line orientation in historical documents. Args: polygons(Sequence[NDArray]): Text regions in the image. image_shape(NDArray): The shape of the image in (height, width). image_path(str): Path to the image. texts(Sequence[str]): Text annotations for regions, aiding in text line localization. points(int): Number of samples taken along each long edge to determine the length of the short edge. cluster_thresh(float): Determines whether the historical document contains only single-line body text. shrink_ratio(Union[float, Sequence]): The width of the text central region is 1/r times the width of the text region; using a single value indicates the same shrinkage ratio for both single-line body text and double-line annotations, while using two values indicates different shrinkage ratios. reorder(bool): Whether it is necessary to rearrange the annotation order of polygons. If the image is not a document image, please pass false. """ SINGLE_ENTRY = 0 DOUBLE_ENTRY = 1 # having thinner width TO_BE_DETERMINED = -1 def __init__(self, polygons: Sequence[NDArray], image_shape: NDArray = None, image_path: str = None, texts: Sequence[str] = None, points: int = 30, cluster_thresh: float = 1.3, shrink_ratio: Union[float, Sequence] = 3, reorder: bool = False): self.image_shape = image_shape self.image_path = image_path self.polygons = polygons self.points = points self.texts = texts self.num_instance = len(polygons) self.cluster_thresh = cluster_thresh self.shrink_ratio = np.array(shrink_ratio) if isinstance(shrink_ratio, Sequence) \ else np.array((shrink_ratio, shrink_ratio)) for r in self.shrink_ratio: assert r > 1, 'Centerline must have proper shrink ratio r > 1.' self.reorder = reorder @classmethod def fitting2reorder(cls, poly, m=0, k=5): """ Args: m: extra sampling k: degree of fitting polynominal Returns: fit_mse: fitting error. mse: fitting error of each side. polynominal: coefficient of polynominal. """ fit_mse = [] mse = [] polynomimal = [] for _ in range(len(poly) // 2): # part 1: fetch out each curve in same order(top to down or vise versa) curve_a = poly[_: _+len(poly)//2] curve_b = np.concatenate([poly[_+len(poly)//2: ], poly[: _]], axis=0) curve_b = curve_b[::-1] # part 2: extra sampling curve_a = extra_sampling(curve_a, m) curve_b = extra_sampling(curve_b, m) # part 3: fitting with polynominal: x = f(y) poly_eff_a = np.polyfit(curve_a[:, 1], curve_a[:, 0], k) poly_eff_b = np.polyfit(curve_b[:, 1], curve_b[:, 0], k) poly_a = np.poly1d(poly_eff_a) poly_b = np.poly1d(poly_eff_b) # part 4: fitting fit_aj = poly_a(curve_a[:, 1]) fit_bj = poly_b(curve_b[:, 1]) # part 5: compute fitting error mse_a = np.sum((fit_aj - curve_a[:, 0]) ** 2) mse_b = np.sum((fit_bj - curve_b[:, 0]) ** 2) # part 6: append return list polynomimal.append((poly_a, poly_b)) mse.append((mse_a, mse_b)) fit_mse.append(mse_a + mse_b) return fit_mse, mse, polynomimal def reorder_polygon(self, k: int = 5, line_ratio: float = 5.0, extra_points: int = 2): """Reorder all polygons and find out each long curve. The process keep the order between `self.polygons` unchanged. If the instance is less-point annotated and hard to determine longerside, then save it and wait for the help of overdetermined results. Long curve will be save in attribute `self.polygons`, `self.polygons` is a list of np.array, which first half represents a long curve. Args: k(int): the degree of polyfit line_ratio(float): if the long length is `line_ratio` times as long as short one, the long curve can be determined. extra_points(int): extra points to sample when fitting the curve. """ if self.reorder: return reordered_polygon = [] to_be_determined = [] to_be_determined_index = [] text_direction = [] # end-start, (0, 1) for i, poly in enumerate(self.polygons): assert len(poly) % 2 == 0 and len(poly) >= 4, \ f'polygon must contains 2k(at least 4) points but receive {poly}.' # two-point(line) annotation: cannot determined if len(poly) == 4: # dist compute: 0->3, 1->2 dist_1 = np.sum(dist(poly[:2], poly[2:][::-1])) # dist compute: 0->1, 3->2 dist_2 = np.sum(dist(np.array([poly[0], poly[-1]]), poly[1:3])) # if one set of sides is significantly longer if dist_1 > dist_2 * line_ratio: result = np.concatenate([poly[1:], poly[:1]], axis=0) text_direction.append(compute_text_direction(result)) reordered_polygon.append(result) elif dist_2 > dist_1 * line_ratio: result = poly text_direction.append(compute_text_direction(result)) reordered_polygon.append(result) else: # if the results cannot be determined now, reorder it later # Note: keep the order inside polygons to_be_determined.append(poly) to_be_determined_index.append(i) reordered_polygon.append([]) continue # promise no underdetermined problem if len(poly) <= 2 * (k + 1): m = max(extra_points, np.ceil((len(poly)//2 - (k + 1)) / (len(poly) // 2 - 1)).astype(np.int32)) else: m = extra_points fit_mse, mse, polynomial = self.fitting2reorder(poly, m, k) min_fit_mse = np.argmin(fit_mse) result = np.concatenate([poly[min_fit_mse:], poly[:min_fit_mse]], axis=0) # try refining if result isn't ideal if not (1/3 < mse[min_fit_mse][0] / (mse[min_fit_mse][1] + 1e-6) < 3) and \ fit_mse[min_fit_mse] > 10: # deleting side with imbalance points argmin = np.array(mse[min_fit_mse]).argmin() if argmin == 0: to_delete = poly[min_fit_mse: min_fit_mse+len(poly)//2] else: # second curve no need to reverse to_delete = np.concatenate([poly[min_fit_mse+len(poly)//2: ], poly[: min_fit_mse]], axis=0) # remove two points with lowest fitting error fit_error = polynomial[min_fit_mse][argmin](to_delete[:, 1]) - to_delete[:, 0] del_points = fit_error.argsort()[:2] # construct new poly avail_index = np.ones(to_delete.shape[:1], dtype=bool) avail_index[del_points] = False if argmin == 0: another_curve = np.concatenate([poly[min_fit_mse+len(poly)//2: ], poly[: min_fit_mse]], axis=0) poly = np.concatenate([to_delete[avail_index], another_curve], axis=0) else: another_curve = poly[min_fit_mse: min_fit_mse+len(poly)//2] poly = np.concatenate([another_curve, to_delete[avail_index]], axis=0) fit_mse_n, mse_n, _ = self.fitting2reorder(poly, m, k) min_fit_mse_n = np.argmin(fit_mse_n) image_path = getattr(self, "image_path", "") text = self.texts[i] if isinstance(getattr(self, "texts", None), list) and i < len(self.texts) else "" if np.min(fit_mse) / (np.min(fit_mse_n) + 1e-3) > 5: result = np.concatenate([poly[min_fit_mse_n:], poly[:min_fit_mse_n]], axis=0) action = "replacing" else: action = "keep" print(f"{image_path} {text}: {action} old {np.min(fit_mse)} by {'new' if action == 'replacing' else 'rejecting new'} {np.min(fit_mse_n)}") text_direction.append(compute_text_direction(result)) reordered_polygon.append(result) document_direction = np.mean(text_direction, axis=0) # no need to normalize again for i, poly in zip(to_be_determined_index, to_be_determined): direct1 = compute_text_direction(poly) direct2 = compute_text_direction(np.concatenate([poly[1:], poly[:1]], axis=0)) if np.sum(direct1 * document_direction) > np.sum(direct2 * document_direction): reordered_polygon[i] = poly text_direction.append(direct1) else: reordered_polygon[i] = np.concatenate([poly[1:], poly[:1]], axis=0) text_direction.append(direct2) self.polygons = reordered_polygon self.direction = norm(np.mean(text_direction, axis=0)) self.check_polygon_order() def determine_short_length(self, points_a: NDArray, points_b: NDArray): """Determine the shorter curve of polygon. Args: points_a(NDArray): shape-like (n, p, 2). points_b(NDArray): shape-like (n, p, 2). points_a and points_b are return value of function `uniform_curve_sampling`. Returns: short side length(NDArray): (n, ) """ raw_dist = dist(points_a, points_b) # n, p # using IQR identify outliers q1 = np.percentile(raw_dist, 25, axis=-1) # n, q3 = np.percentile(raw_dist, 75, axis=-1) iqr = q3 - q1 lower_bound = q1 - 1 * iqr upper_bound = q3 + 1 * iqr # need to filter outliers one by one (due to numbers of outliers isn't same) mean = np.zeros((len(points_a), )) # n, for i, raw in enumerate(raw_dist): refine_dist = raw[(lower_bound[i] <= raw) & (raw <= upper_bound[i])] mean[i] = np.mean(refine_dist, axis=-1) return mean def clustering_polygons(self, shorter_length: NDArray): """Clustering polygons through shorter length by KMeans. Returns: label(NDArray): (n, ) """ kmeans = KMeans(n_clusters=2, n_init=3).fit(shorter_length.reshape(-1, 1)) cluster_center = kmeans.cluster_centers_ label = kmeans.labels_ # switching label when single entries are assigned smaller width if cluster_center[self.SINGLE_ENTRY] < cluster_center[self.DOUBLE_ENTRY]: label = np.where(label==self.SINGLE_ENTRY, self.DOUBLE_ENTRY, self.SINGLE_ENTRY) cluster_center = cluster_center[::-1] # if the center of two clusters is close enough, merge them! if cluster_center[self.SINGLE_ENTRY] < cluster_center[self.DOUBLE_ENTRY] * self.cluster_thresh: label = np.ones_like(label) * self.SINGLE_ENTRY cluster_center = (cluster_center[self.SINGLE_ENTRY],) else: # if keeping two cluster, using reading order to refine the result determined = np.zeros_like(label) # step 1: picking out double entry for i in range(len(label)-1): if determined[i]: continue if label[i] == self.DOUBLE_ENTRY and label[i+1] == self.DOUBLE_ENTRY: y_less = (np.min(self.polygons[i][:, 1]), np.min(self.polygons[i+1][:, 1])) y_greater = (np.max(self.polygons[i][:, 1]), np.max(self.polygons[i+1][:, 1])) _iou = max(0, (np.min(y_greater) - np.max(y_less)) / (np.max(y_greater) - np.min(y_less) + 1e-4)) if _iou > 0.5: determined[i] = determined[i+1] = True # step 2: recompute cluster center if np.any(determined): # keeping the minimum for maximize the gap between clsuter center. cluster_center[self.DOUBLE_ENTRY] = min(np.mean(shorter_length[determined == True]), cluster_center[self.DOUBLE_ENTRY]) # step 3: transformation according to reading order # continuous text line in same column cannot have same label for i in range(len(label)-1): if determined[i] and determined[i+1]: continue # step 1: find bottom line of line[i] _, bottom_0 = find_top_bottom(self.polygons[i]) # step 2: find top line of line[i+1] top_1, _ = find_top_bottom(self.polygons[i+1]) # step 3: projecting mid point of top and bottom line, prog = a·b/|b| top_proj = np.dot(np.mean(top_1, axis=0), self.direction) bot_proj = np.dot(np.mean(bottom_0, axis=0), self.direction) # step 4: computing normal vector of text direction normal_vector = np.array([self.direction[1], -self.direction[0]]) # step 5: compute projection, avoid changing text blocks _iou = section_iou(np.array([np.dot(top_1[0], normal_vector), np.dot(top_1[1], normal_vector)]), np.array([np.dot(bottom_0[0], normal_vector), np.dot(bottom_0[1], normal_vector)])) # step 6: if in the same column (not switching blocks) if bot_proj < top_proj and _iou > 0.1: # step 7: promising continuous text line in same column cannot have same label if determined[i]: label[i + 1] = self.SINGLE_ENTRY if label[i]==self.DOUBLE_ENTRY else self.DOUBLE_ENTRY elif determined[i+1]: label[i] = self.SINGLE_ENTRY if label[i+1]==self.DOUBLE_ENTRY else self.DOUBLE_ENTRY else: if shorter_length[i] < shorter_length[i+1]: label[i] = self.DOUBLE_ENTRY label[i+1] = self.SINGLE_ENTRY else: label[i+1] = self.DOUBLE_ENTRY label[i] = self.SINGLE_ENTRY determined[i] = determined[i+1] = True # step 4: recompute cluster center # using the mean of determined one to get the new center if np.any((label == self.SINGLE_ENTRY) & (determined == True)): cluster_center[self.SINGLE_ENTRY] = max(np.mean(shorter_length[(label == self.SINGLE_ENTRY) & (determined == True)]), cluster_center[self.SINGLE_ENTRY]) if np.any((label == self.DOUBLE_ENTRY) & (determined == True)): cluster_center[self.DOUBLE_ENTRY] = min(np.mean(shorter_length[(label == self.DOUBLE_ENTRY) & (determined == True)]), cluster_center[self.DOUBLE_ENTRY]) # step 5: using recompute center to determine the remain for i in range(len(label)): if determined[i]: continue label[i] = self.SINGLE_ENTRY if abs(shorter_length[i] - cluster_center[self.SINGLE_ENTRY]) \ < abs(shorter_length[i] - cluster_center[self.DOUBLE_ENTRY]) else self.DOUBLE_ENTRY determined[i] = True return label, cluster_center def compute_centerline(self, points_a: NDArray, points_b: NDArray): """Computing centerline using sampled points and concatenate them nose to tail. Different shrink ratio may be used on single entries and double entries. Args: points_a(NDArray): shape-like (n, p, 2). points_b(NDArray): shape-like (n, p, 2). points_a and points_b are return value of function `uniform_curve_sampling`. r(float): shrink ratio of centerline, the area will shrink to 1/r respect to original polygon. Returns: center_a, center_b(NDArray): having same shape as points_a, points_b. center_a is the edge of centerline that near a, vice versa. """ r = self.shrink_ratio[self.labels][:, np.newaxis, np.newaxis] # (n, 1, 1) theta = 0.5 - 1 / (2 * r) # (n, p, 2) center_a = points_a * (1 - theta) + points_b * theta center_b = points_a * theta + points_b * (1 - theta) return np.concatenate([center_a, center_b[:, ::-1]], axis=1) # (n, 2p, 2) def preprocess(self): self.reorder_polygon() sample_a = np.zeros((self.num_instance, self.points, 2)) sample_b = np.zeros((self.num_instance, self.points, 2)) for i, poly in enumerate(self.polygons): curve_a, curve_b = poly[:len(poly)//2], poly[len(poly)//2:][::-1] sample_a[i] = uniform_curve_sampling(curve_a, self.points) sample_b[i] = uniform_curve_sampling(curve_b, self.points) shortside_length = self.determine_short_length(sample_a, sample_b) self.labels, self.cluster_center = self.clustering_polygons(shortside_length) self.preprocessed = True def get_length(self, curve): segment_length = dist(curve, np.concatenate([curve[0:1], curve[:-1]], axis=0)) # (k, ) accumulate_length = np.cumsum(segment_length) # (k, ) curve_length = accumulate_length[-1] return curve_length def vertical_aspect_ratio(self): self.reorder_polygon() sample_a = np.zeros((self.num_instance, self.points, 2)) sample_b = np.zeros((self.num_instance, self.points, 2)) longside_length = np.zeros((self.num_instance, )) for i, poly in enumerate(self.polygons): curve_a, curve_b = poly[:len(poly)//2], poly[len(poly)//2:][::-1] sample_a[i] = uniform_curve_sampling(curve_a, self.points) sample_b[i] = uniform_curve_sampling(curve_b, self.points) longside_length[i] = (self.get_length(curve_a) + self.get_length(curve_b)) / 2 shortside_length = self.determine_short_length(sample_a, sample_b) return longside_length / shortside_length def aspect_ratio(self): self.reorder_polygon() sample_a = np.zeros((self.num_instance, self.points, 2)) sample_b = np.zeros((self.num_instance, self.points, 2)) longside_length = np.zeros((self.num_instance, )) for i, poly in enumerate(self.polygons): curve_a, curve_b = poly[:len(poly)//2], poly[len(poly)//2:][::-1] sample_a[i] = uniform_curve_sampling(curve_a, self.points) sample_b[i] = uniform_curve_sampling(curve_b, self.points) longside_length[i] = (self.get_length(curve_a) + self.get_length(curve_b)) / 2 shortside_length = self.determine_short_length(sample_a, sample_b) return np.where(longside_length>shortside_length, longside_length / shortside_length, shortside_length / longside_length) def process(self): self.reorder_polygon() sample_a = np.zeros((self.num_instance, self.points, 2)) sample_b = np.zeros((self.num_instance, self.points, 2)) for i, poly in enumerate(self.polygons): curve_a, curve_b = poly[:len(poly)//2], poly[len(poly)//2:][::-1] sample_a[i] = uniform_curve_sampling(curve_a, self.points) sample_b[i] = uniform_curve_sampling(curve_b, self.points) if not getattr(self, "preprocessed", False): shortside_length = self.determine_short_length(sample_a, sample_b) self.labels, self.cluster_center = self.clustering_polygons(shortside_length) self.center_line = self.compute_centerline(sample_a, sample_b) # n, 2p, 2 def generate_kernelmap(self): """Generate text center line map for single-line and double-line, respectively. """ if not getattr(self, 'image_shape', False): warnings.warn('object don\'t have image_shape attr, cannot generate maps.') return None, None kernel_single = np.zeros(self.image_shape, dtype=np.uint8) kernel_double = np.zeros(self.image_shape, dtype=np.uint8) cv2.fillPoly(kernel_single, self.center_line[self.labels==self.SINGLE_ENTRY].astype(np.int32), 255) cv2.fillPoly(kernel_double, self.center_line[self.labels==self.DOUBLE_ENTRY].astype(np.int32), 255) return kernel_single, kernel_double def check_polygon_order(self): """Checking polygon order after reorder polygons. """ for poly in self.polygons: direction = compute_text_direction(poly) if np.dot(direction, self.direction) < np.cos(np.pi/6): print(f'may find fault direction in {getattr(self, "image_path", "")}, \ direction difference: {np.dot(direction, self.direction)}') def output_json(self): '''Adding labels to annotations when preprocessing. Returning a list of dict that will behave as `data['instances']`. ''' results = [] assert self.texts is not None, 'text is none, json cannot be creates.' for poly, label, text in zip(self.polygons, self.labels, self.texts): results.append(dict( ignore=False, text=text, bbox_label=int(label), polygon=poly.reshape(-1).astype(int).tolist() )) return results