-
-
-## TODO
-- [ ] Support to run the webserver with the designated GT and image files
-- [ ] Calculate the length of text based on grapheme for Mulit-lingual dataset
+* Note : For scalewise evaluation, we measure the ratio of the shorter length (text height) of the text-box to the longer length of the image.
+Through this, evaluation for each ratio can be performed. To adjust the scales, please use SCALE_BINS argument.
## Citation
```
@@ -118,7 +130,6 @@ python web.py --BOX_TYPE=[LTRB,QUAD,POLY] --PORT=8080
CLEval has been proposed to make fair evaluation in the OCR community, so we want to hear from many researchers. We welcome any feedbacks to our metric, and appreciate pull requests if you have any comments or improvements.
## License
-
```
Copyright (c) 2020-present NAVER Corp.
@@ -140,3 +151,21 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
```
+
+### Contribute
+Please use pre-commit which uses Black and Isort.
+```
+$ pip install pre-commit
+$ pre-commit install
+```
+
+##### Step By Step
+1. Write an issue.
+2. Match code style (black, isort)
+3. Wirte test code.
+4. Delete branch after Squash&Merge.
+
+Required Approve: 1
+
+## Code Maintainer
+- Donghyun Kim (artit.anthony@gmail.com)
diff --git a/arg_parser.py b/arg_parser.py
deleted file mode 100644
index 474e772..0000000
--- a/arg_parser.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import argparse
-
-def str2bool(v):
- return v.lower() in ("yes", "y", "true", "t", "1")
-
-parser = argparse.ArgumentParser(description="test global argument parser")
-
-# script parameters
-parser.add_argument('-g', '--GT_PATH', default='gt/gt.zip', help="Path of the Ground Truth file.")
-parser.add_argument('-s', '--SUBMIT_PATH', default='submit.zip', help="Path of your method's results file.")
-
-# webserver parameters
-parser.add_argument('-o', '--OUTPUT_PATH', default='output/', help="Path to a directory where to copy the file that contains per-sample results.")
-parser.add_argument('-p', '--PORT', default=8080, help='port number to show')
-
-# result format related parameters
-parser.add_argument('--BOX_TYPE', default='QUAD', choices=['LTRB', 'QUAD', 'POLY'])
-parser.add_argument('--TRANSCRIPTION', action='store_true')
-parser.add_argument('--CONFIDENCES', action='store_true')
-parser.add_argument('--CRLF', action='store_true')
-
-# end-to-end related parameters
-parser.add_argument('--E2E', action='store_true')
-parser.add_argument('--CASE_SENSITIVE', default=True, type=str2bool)
-parser.add_argument('--RS', default=True, type=str2bool)
-
-# evaluation related parameters
-parser.add_argument('--AREA_PRECISION_CONSTRAINT', type=float, default=0.5)
-parser.add_argument('--GRANULARITY_PENALTY_WEIGHT', type=float, default=1.0)
-parser.add_argument('--VERTICAL_ASPECT_RATIO_THRES', default=2.0)
-
-# other parameters
-parser.add_argument('-t', '--NUM_WORKERS', default=2, type=int, help='number of threads to use')
-parser.add_argument('--GT_SAMPLE_NAME_2_ID', default='([0-9]+)')
-parser.add_argument('--DET_SAMPLE_NAME_2_ID', default='([0-9]+)')
-parser.add_argument('--PER_SAMPLE_RESULTS', default=True, type=str2bool)
-
-PARAMS = parser.parse_args()
diff --git a/box_types.py b/box_types.py
deleted file mode 100644
index 39e04d8..0000000
--- a/box_types.py
+++ /dev/null
@@ -1,606 +0,0 @@
-import abc
-import numpy as np
-import cv2
-import Polygon as polygon3
-from shapely.geometry import Polygon as shapely_poly
-import math
-from arg_parser import PARAMS
-
-MAX_FIDUCIAL_POINTS = 50
-
-
-def get_midpoints(p1, p2):
- return (p1[0] + p2[0])/2, (p1[1] + p2[1])/2
-
-
-def point_distance(p1, p2):
- distx = math.fabs(p1[0] - p2[0])
- disty = math.fabs(p1[1] - p2[1])
- return math.sqrt(distx * distx + disty * disty)
-
-
-def point_angle(p1, p2):
- return (np.arctan2(p1[0]-p2[0], p1[1]-p2[1]) * 180 / np.pi + 360) % 360
-
-
-def corner_continuous_check(index1, index2, index3, index4):
- pass
-
-
-class Box(metaclass=abc.ABCMeta):
- def __init__(self, points, confidence, transcription):
- self.points = points
- self.confidence = confidence
- self.transcription = transcription
- self.is_dc = transcription == "###"
-
- @abc.abstractmethod
- def __and__(self, other) -> float:
- """Returns intersection between two objects"""
- pass
-
- @abc.abstractmethod
- def subtract(self, other):
- """polygon subtraction"""
- pass
-
- @abc.abstractmethod
- def center(self):
- pass
-
- @abc.abstractmethod
- def center_distance(self, other):
- """center distance between each box"""
-
- @abc.abstractmethod
- def diagonal_length(self) -> float:
- """Returns diagonal length for box-level"""
- pass
-
- @abc.abstractmethod
- def is_inside(self, x, y) -> bool:
- """Returns point (x, y) is inside polygon."""
- pass
-
- @abc.abstractmethod
- def make_polygon_obj(self):
- # TODO: docstring 좀 더 자세히 적기
- """Make polygon object to calculate for future"""
- pass
-
- @abc.abstractmethod
- def pseudo_character_center(self) -> list:
- """get character level boxes for TedEval pseudo center"""
- pass
-
-
-class QUAD(Box):
- """Points should be x1,y1,...,x4,y4 (8 points) format"""
- def __init__(self, points, confidence=0.0, transcription=""):
- super(QUAD, self).__init__(points, confidence, transcription)
- self.polygon = self.make_polygon_obj()
- if self.is_dc:
- self.transcription = "#" * self.pseudo_transcription_length()
-
- def __and__(self, other) -> float:
- """Get intersection between two area"""
- poly_intersect = self.polygon & other.polygon
- if len(poly_intersect) == 0:
- return 0.0
- return poly_intersect.area()
-
- def subtract(self, other):
- self.polygon = self.polygon - other.polygon
-
- def center(self):
- return self.polygon.center()
-
- def center_distance(self, other):
- return point_distance(self.center(), other.center())
-
- def area(self):
- return self.polygon.area()
-
- def __or__(self, other):
- return self.polygon.area() + other.polygon.area() - (self & other)
-
- def make_polygon_obj(self):
- point_matrix = np.empty((4, 2), np.int32)
- point_matrix[0][0] = int(self.points[0])
- point_matrix[0][1] = int(self.points[1])
- point_matrix[1][0] = int(self.points[2])
- point_matrix[1][1] = int(self.points[3])
- point_matrix[2][0] = int(self.points[4])
- point_matrix[2][1] = int(self.points[5])
- point_matrix[3][0] = int(self.points[6])
- point_matrix[3][1] = int(self.points[7])
- return polygon3.Polygon(point_matrix)
-
- def aspect_ratio(self):
- top_side = point_distance((self.points[0], self.points[1]), (self.points[2], self.points[3]))
- right_side = point_distance((self.points[2], self.points[3]), (self.points[4], self.points[5]))
- bottom_side = point_distance((self.points[4], self.points[5]), (self.points[6], self.points[7]))
- left_side = point_distance((self.points[6], self.points[7]), (self.points[0], self.points[1]))
- avg_hor = (top_side + bottom_side) / 2
- avg_ver = (right_side + left_side) / 2
-
- return (avg_ver + 1e-5) / (avg_hor + 1e-5)
-
- def pseudo_transcription_length(self):
- return min(round(0.5+(max(self.aspect_ratio(), 1/self.aspect_ratio()))), 10)
-
- def pseudo_character_center(self):
- chars = list()
- length = len(self.transcription)
- aspect_ratio = self.aspect_ratio()
-
- if length == 0:
- return chars
-
- if aspect_ratio < PARAMS.VERTICAL_ASPECT_RATIO_THRES:
- left_top = self.points[0], self.points[1]
- right_top = self.points[2], self.points[3]
- right_bottom = self.points[4], self.points[5]
- left_bottom = self.points[6], self.points[7]
- else:
- left_top = self.points[6], self.points[7]
- right_top = self.points[0], self.points[1]
- right_bottom = self.points[2], self.points[3]
- left_bottom = self.points[4], self.points[5]
-
- p1 = get_midpoints(left_top, left_bottom)
- p2 = get_midpoints(right_top, right_bottom)
-
- unit_x = (p2[0] - p1[0]) / length
- unit_y = (p2[1] - p1[1]) / length
-
- for i in range(length):
- x = p1[0] + unit_x / 2 + unit_x * i
- y = p1[1] + unit_y / 2 + unit_y * i
- chars.append((x, y))
- return chars
-
- def diagonal_length(self) -> float:
- left_top = self.points[0], self.points[1]
- right_top = self.points[2], self.points[3]
- right_bottom = self.points[4], self.points[5]
- left_bottom = self.points[6], self.points[7]
- diag1 = point_distance(left_top, right_bottom)
- diag2 = point_distance(right_top, left_bottom)
- return (diag1 + diag2) / 2
-
- def is_inside(self, x, y) -> bool:
- return self.polygon.isInside(x, y)
-
-
-class POLY(Box):
- """Points should be x1,y1,...,xn,yn (2*n points) format"""
- def __init__(self, points, confidence=0.0, transcription=""):
- super(POLY, self).__init__(points, confidence, transcription)
- self.num_points = len(self.points) // 2
- self.polygon = self.make_polygon_obj()
- self._aspect_ratio = self.make_aspect_ratio()
- if self.is_dc:
- self.transcription = "#" * self.pseudo_transcription_length()
-
- def __and__(self, other):
- """Get intersection between two area"""
- poly_intersect = self.polygon.intersection(other.polygon)
- return poly_intersect.area
-
- def subtract(self, other):
- """get substraction"""
- self.polygon = self.polygon.difference(self.polygon.intersection(other.polygon))
-
- def __or__(self, other):
- return 1.0
-
- def area(self):
- return self.polygon.area
-
- def center(self):
- return self.polygon.centroid.coords[0]
-
- def center_distance(self, other):
- try:
- return point_distance(self.center(), other.center())
- except:
- return 0.0001
-
- def diagonal_length(self):
- left_top = self.points[0], self.points[1]
- right_top = self.points[self.num_points-2], self.points[self.num_points-1]
- right_bottom = self.points[self.num_points], self.points[self.num_points+1]
- left_bottom = self.points[self.num_points*2-2], self.points[self.num_points*2-1]
-
- diag1 = point_distance(left_top, right_bottom)
- diag2 = point_distance(right_top, left_bottom)
-
- return (diag1 + diag2) / 2
-
- def is_inside(self, x, y) -> bool:
- return self.polygon.contains(Point(x, y))
-
- def check_corner_points_are_continuous(self, lt, rt, rb, lb):
- count = 0
- while lt != rt:
- lt = (lt+1) % self.num_points
- count += 1
-
- while rb != lb:
- rb = (rb+1) % self.num_points
- count += 1
-
- return True
-
- def get_four_max_distance_from_center(self):
- center_x, center_y = self.center()
- distance_from_center = list()
- point_x = self.points[0::2]
- point_y = self.points[1::2]
-
- for px, py in zip(point_x, point_y):
- distance_from_center.append(point_distance((center_x, center_y), (px, py)))
-
- distance_idx_max_order = np.argsort(distance_from_center)[::-1]
- return distance_idx_max_order[:4]
-
- def make_polygon_obj(self):
- point_x = self.points[0::2]
- point_y = self.points[1::2]
- # in TotalText dataset, there there are under 4 points annotation for Polygon shape
- # so, we have to deal with it
-
- # if points are given 3, fill last quad points with left bottom coordinates
- if len(point_x) == len(point_y) == 3:
- point_x.append(point_x[0])
- point_y.append(point_y[2])
- self.points.append(point_x[0])
- self.points.append(point_y[2])
- self.num_points = len(self.points) // 2
- # if points are given 2, copy value 2 times
- elif len(point_x) == len(point_y) == 2:
- point_x *= 2
- point_y *= 2
- self.points.append(point_x[1])
- self.points.append(point_y[0])
- self.points.append(point_x[0])
- self.points.append(point_y[1])
- self.num_points = len(self.points) // 2
- # if points are given 1, copy value 4 times
- elif len(point_x) == len(point_y) == 1:
- point_x *= 4
- point_y *= 4
- for _ in range(3):
- self.points.append(point_x[0])
- self.points.append(point_x[0])
- self.num_points = len(self.points) // 2
- return shapely_poly(np.stack([point_x, point_y], axis=1)).buffer(0)
-
- def aspect_ratio(self):
- return self._aspect_ratio
-
- def pseudo_transcription_length(self):
- return min(round(0.5+ (max(self._aspect_ratio, 1/self._aspect_ratio))), 10)
-
- def make_aspect_ratio(self):
- np.array(np.reshape(self.points, [-1, 2]))
- rect = cv2.minAreaRect(np.array(np.reshape(self.points, [-1, 2]), dtype=np.float32))
- width = rect[1][0]
- height = rect[1][1]
-
- width += 1e-6
- height += 1e-6
-
- return min(10, height/width) + 1e+5
-
- def pseudo_character_center(self):
- chars = list()
- length = len(self.transcription)
-
- # Prepare polygon line estimation with interpolation
- point_x = self.points[0::2]
- point_y = self.points[1::2]
- points_x_top = point_x[:self.num_points//2]
- points_x_bottom = point_x[self.num_points//2:]
- points_y_top = point_y[:self.num_points//2]
- points_y_bottom = point_y[self.num_points//2:]
-
- # reverse bottom point order from left to right
- points_x_bottom = points_x_bottom[::-1]
- points_y_bottom = points_y_bottom[::-1]
-
- num_interpolation_section = (self.num_points//2) - 1
- num_points_to_interpolate = length
-
- new_point_x_top, new_point_x_bottom = list(), list()
- new_point_y_top, new_point_y_bottom = list(), list()
-
- for sec_idx in range(num_interpolation_section):
- start_x_top, end_x_top = points_x_top[sec_idx], points_x_top[sec_idx+1]
- start_y_top, end_y_top = points_y_top[sec_idx], points_y_top[sec_idx+1]
- start_x_bottom, end_x_bottom = points_x_bottom[sec_idx], points_x_bottom[sec_idx + 1]
- start_y_bottom, end_y_bottom = points_y_bottom[sec_idx], points_y_bottom[sec_idx + 1]
-
- diff_x_top = (end_x_top - start_x_top) / num_points_to_interpolate
- diff_y_top = (end_y_top - start_y_top) / num_points_to_interpolate
- diff_x_bottom = (end_x_bottom - start_x_bottom) / num_points_to_interpolate
- diff_y_bottom = (end_y_bottom - start_y_bottom) / num_points_to_interpolate
-
- new_point_x_top.append(start_x_top)
- new_point_x_bottom.append(start_x_bottom)
- new_point_y_top.append(start_y_top)
- new_point_y_bottom.append(start_y_bottom)
-
- for num_pt in range(1, num_points_to_interpolate):
- new_point_x_top.append(int(start_x_top + diff_x_top * num_pt))
- new_point_x_bottom.append(int(start_x_bottom + diff_x_bottom * num_pt))
- new_point_y_top.append(int(start_y_top + diff_y_top * num_pt))
- new_point_y_bottom.append(int(start_y_bottom + diff_y_bottom * num_pt))
- new_point_x_top.append(points_x_top[-1])
- new_point_y_top.append(points_y_top[-1])
- new_point_x_bottom.append(points_x_bottom[-1])
- new_point_y_bottom.append(points_y_bottom[-1])
-
- len_section_for_single_char = (len(new_point_x_top)-1) / len(self.transcription)
- print(self.num_points)
- print(len(self.transcription))
-
- for c in range(len(self.transcription)):
- print(len(new_point_x_top), c, len_section_for_single_char)
- center_x = (new_point_x_top[int(c*len_section_for_single_char)] +
- new_point_x_top[int((c+1)*len_section_for_single_char)] +
- new_point_x_bottom[int(c*len_section_for_single_char)] +
- new_point_x_bottom[int((c+1)*len_section_for_single_char)]) / 4
-
- center_y = (new_point_y_top[int(c*len_section_for_single_char)] +
- new_point_y_top[int((c+1)*len_section_for_single_char)] +
- new_point_y_bottom[int(c*len_section_for_single_char)] +
- new_point_y_bottom[int((c+1)*len_section_for_single_char)]) / 4
-
- chars.append((center_x, center_y))
- return chars
-
- # def pseudo_character_center(self):
- # chars = list()
-
- # # TODO: write comment more fancier(?)
- # # Prepare polygon line estimation with interpolation
-
- # point_x = self.points[0::2]
- # point_y = self.points[1::2]
- # points_x_top = point_x[:self.num_points//2]
- # points_x_bottom = point_x[self.num_points//2:]
- # points_y_top = point_y[:self.num_points//2]
- # points_y_bottom = point_y[self.num_points//2:]
-
- # points_x_bottom = points_x_bottom[::-1]
- # points_y_bottom = points_y_bottom[::-1]
- # # print(points_x_top, points_x_bottom, points_y_top, points_y_bottom)
-
- # num_interpolation_section = (self.num_points//2) - 1
- # num_points_to_interpolate = MAX_FIDUCIAL_POINTS // num_interpolation_section
-
- # # TODO: using computer vision?
- # new_point_x_top, new_point_x_bottom = list(), list()
- # new_point_y_top, new_point_y_bottom = list(), list()
-
- # for sec_idx in range(num_interpolation_section):
- # start_x_top, end_x_top = points_x_top[sec_idx], points_x_top[sec_idx+1]
- # start_y_top, end_y_top = points_y_top[sec_idx], points_y_top[sec_idx+1]
- # start_x_bottom, end_x_bottom = points_x_bottom[sec_idx], points_x_bottom[sec_idx + 1]
- # start_y_bottom, end_y_bottom = points_y_bottom[sec_idx], points_y_bottom[sec_idx + 1]
-
- # diff_x_top = (end_x_top - start_x_top) / num_points_to_interpolate
- # diff_y_top = (end_y_top - start_y_top) / num_points_to_interpolate
- # diff_x_bottom = (end_x_bottom - start_x_bottom) / num_points_to_interpolate
- # diff_y_bottom = (end_y_bottom - start_y_bottom) / num_points_to_interpolate
-
- # new_point_x_top.append(start_x_top)
- # new_point_x_bottom.append(start_x_bottom)
- # new_point_y_top.append(start_y_top)
- # new_point_y_bottom.append(start_y_bottom)
-
- # for num_pt in range(1, num_points_to_interpolate):
- # new_point_x_top.append(int(start_x_top + diff_x_top * num_pt))
- # new_point_x_bottom.append(int(start_x_bottom + diff_x_bottom * num_pt))
- # new_point_y_top.append(int(start_y_top + diff_y_top * num_pt))
- # new_point_y_bottom.append(int(start_y_bottom + diff_y_bottom * num_pt))
-
- # len_section_for_single_char = len(new_point_x_top) / len(self.transcription)
-
- # for c in range(len(self.transcription)):
- # center_x = (new_point_x_top[int(c*len_section_for_single_char)] +
- # new_point_x_top[min(int((c+1)*len_section_for_single_char), len(new_point_x_top)-1)] +
- # new_point_x_bottom[int(c*len_section_for_single_char)] +
- # new_point_x_bottom[min(int((c+1)*len_section_for_single_char), len(new_point_x_top)-1)]) / 4
-
- # center_y = (new_point_y_top[int(c*len_section_for_single_char)] +
- # new_point_y_top[min(int((c+1)*len_section_for_single_char), len(new_point_x_top)-1)] +
- # new_point_y_bottom[int(c*len_section_for_single_char)] +
- # new_point_y_bottom[min(int((c+1)*len_section_for_single_char), len(new_point_x_top)-1)]) / 4
-
- # chars.append((center_x, center_y))
- # return chars
-
- # def pseudo_character_center_using_curve_fitting(self):
- # if self.num_points == 4:
- # return self.pseudo_character_center_prev()
- #
- # chars = list()
- #
- # point_x = self.points[0::2]
- # point_y = self.points[1::2]
- #
- # center_x, center_y = self.center()
- #
- # # calculate distance between each point & center
- # distance = []
- # for px, py in zip(point_x, point_y):
- # distance.append(point_distance((center_x, center_y), (px, py)))
- #
- # # filter 4 points with maximum distance (to find each corner points)
- # distance_max_idx_order = np.argsort(distance)[::-1][:4]
- #
- # # distinguish left/right point by x coordinate difference with center point
- # left_candidate_indices = []
- # right_candidate_indices = []
- #
- # for idx in distance_max_idx_order:
- # if point_x[idx] < center_x:
- # left_candidate_indices.append(idx)
- # else:
- # right_candidate_indices.append(idx)
- #
- # # there should be 2: 2 points for each left/right location
- # print(self.transcription, left_candidate_indices, right_candidate_indices)
- #
- # # case
- # # find minimum distance point with single left/right points, and append it to left/right candidate
- # if len(left_candidate_indices) == 0 or len(right_candidate_indices) == 0:
- # left_candidate_indices = [0, self.num_points-1]
- # right_candidate_indices = [self.num_points//2-1, self.num_points//2]
- #
- # if not len(left_candidate_indices) == len(right_candidate_indices):
- # distance_between_corner = list()
- # if len(left_candidate_indices) == 1:
- # for right_idx in right_candidate_indices:
- # distance_between_corner.append(point_distance((point_x[right_idx], point_y[right_idx]),
- # (point_x[left_candidate_indices[0]],
- # point_y[left_candidate_indices[0]])))
- # elif len(right_candidate_indices) == 1:
- # for left_idx in left_candidate_indices:
- # distance_between_corner.append(point_distance((point_x[left_idx], point_y[left_idx]),
- # (point_x[right_candidate_indices[0]],
- # point_y[right_candidate_indices[0]])))
- #
- # min_distance_point_idx = np.argsort(distance_between_corner)[0]
- # if len(left_candidate_indices) == 1:
- # left_candidate_indices.append(right_candidate_indices[min_distance_point_idx])
- # right_candidate_indices.pop(min_distance_point_idx)
- # else:
- # right_candidate_indices.append(left_candidate_indices[min_distance_point_idx])
- # left_candidate_indices.pop(min_distance_point_idx)
- #
- # # distinguish top / bottom points by y coordinate difference compared with each left/right points
- # if point_angle((point_x[left_candidate_indices[0]], point_y[left_candidate_indices[0]]), (center_x, center_y)) <\
- # point_angle((point_x[left_candidate_indices[1]], point_y[left_candidate_indices[1]]), (center_x, center_y)):
- # left_top_idx = left_candidate_indices[0]
- # left_bottom_idx = left_candidate_indices[1]
- # else:
- # left_top_idx = left_candidate_indices[1]
- # left_bottom_idx = left_candidate_indices[0]
- #
- # if point_angle((point_x[right_candidate_indices[0]], point_y[right_candidate_indices[0]]), (center_x, center_y)) > \
- # point_angle((point_x[right_candidate_indices[1]], point_y[right_candidate_indices[1]]), (center_x, center_y)):
- # right_top_idx = right_candidate_indices[0]
- # right_bottom_idx = right_candidate_indices[1]
- # else:
- # right_top_idx = right_candidate_indices[1]
- # right_bottom_idx = right_candidate_indices[0]
- #
- # # if point_y[left_candidate_indices[0]] < point_y[left_candidate_indices[1]]:
- # # left_top_idx = left_candidate_indices[0]
- # # left_bottom_idx = left_candidate_indices[1]
- # # else:
- # # left_top_idx = left_candidate_indices[1]
- # # left_bottom_idx = left_candidate_indices[0]
- # #
- # # if point_y[right_candidate_indices[0]] < point_y[right_candidate_indices[1]]:
- # # right_top_idx = right_candidate_indices[0]
- # # right_bottom_idx = right_candidate_indices[1]
- # # else:
- # # right_top_idx = right_candidate_indices[1]
- # # right_bottom_idx = right_candidate_indices[0]
- #
- # top_x, top_y = list(), list()
- # bottom_x, bottom_y = list(), list()
- # top_start = left_top_idx
- # top_end = right_top_idx
- # bottom_start = right_bottom_idx
- # bottom_end = left_bottom_idx
- #
- # self.check_corner_points_are_continuous(left_top_idx, right_top_idx, right_bottom_idx, left_bottom_idx)
- #
- # while top_start != top_end:
- # top_x.append(point_x[top_start])
- # top_y.append(point_y[top_start])
- # top_start = (top_start+1) % self.num_points
- # top_x.append(point_x[top_end])
- # top_y.append(point_y[top_end])
- #
- # while bottom_start != bottom_end:
- # bottom_x.append(point_x[bottom_start])
- # bottom_y.append(point_y[bottom_start])
- # bottom_start = (bottom_start+1) % self.num_points
- #
- # bottom_x.append(point_x[bottom_end])
- # bottom_y.append(point_y[bottom_end])
- #
- # # reverse bottom points to make it left -> right order
- # bottom_x = bottom_x[::-1]
- # bottom_y = bottom_y[::-1]
- #
- # # pseudo interpolation for more accurate polynomial estimation
- # new_point_x_top, new_point_x_bottom = list(), list()
- # new_point_y_top, new_point_y_bottom = list(), list()
- #
- # NUM_POINTS_TO_FILL = 3
- #
- # new_point_x_top.append(top_x[0])
- # new_point_y_top.append(top_y[0])
- # for sec_idx in range(len(top_x)-1):
- # start_top_x, end_top_x = top_x[sec_idx], top_x[sec_idx+1]
- # start_top_y, end_top_y = top_y[sec_idx], top_y[sec_idx+1]
- #
- # diff_x_top = (end_top_x - start_top_x) / NUM_POINTS_TO_FILL
- # diff_y_top = (end_top_y - start_top_y) / NUM_POINTS_TO_FILL
- #
- # new_point_x_top.append(start_top_x)
- # new_point_y_top.append(start_top_y)
- #
- # for num_pt in range(1, NUM_POINTS_TO_FILL+1):
- # new_point_x_top.append(int(start_top_x + diff_x_top * num_pt))
- # new_point_y_top.append(int(start_top_y + diff_y_top * num_pt))
- #
- # new_point_x_bottom.append(bottom_x[0])
- # new_point_y_bottom.append(bottom_y[0])
- # for sec_idx in range(len(bottom_x) - 1):
- # start_bottom_x, end_bottom_x = bottom_x[sec_idx], bottom_x[sec_idx + 1]
- # start_bottom_y, end_bottom_y = bottom_y[sec_idx], bottom_y[sec_idx + 1]
- #
- # diff_x_top = (end_bottom_x - start_bottom_x) / NUM_POINTS_TO_FILL
- # diff_y_top = (end_bottom_y - start_bottom_y) / NUM_POINTS_TO_FILL
- #
- # new_point_x_bottom.append(start_bottom_x)
- # new_point_y_bottom.append(start_bottom_y)
- #
- # for num_pt in range(1, NUM_POINTS_TO_FILL + 1):
- # new_point_x_bottom.append(int(start_bottom_x + diff_x_top * num_pt))
- # new_point_y_bottom.append(int(start_bottom_y + diff_y_top * num_pt))
- #
- # # do polynomial curve fitting
- # top_curve = np.poly1d(np.polyfit(np.array(new_point_x_top), np.array(new_point_y_top), 2))
- # bottom_curve = np.poly1d(np.polyfit(np.array(new_point_x_bottom), np.array(new_point_y_bottom), 2))
- #
- # # # do polynomial curve fitting
- # # top_curve = np.poly1d(np.polyfit(np.array(top_x), np.array(top_y), 2))
- # # bottom_curve = np.poly1d(np.polyfit(np.array(bottom_x), np.array(bottom_y), 2))
- #
- # # point interpolation
- # interpolated_top_x = np.linspace(top_x[0], top_x[-1], len(self.transcription)+1)
- # interpolated_bottom_x = np.linspace(bottom_x[0], bottom_x[-1], len(self.transcription)+1)
- #
- # # estimate middle point from top/bottom polynomial
- # interpolated_top_y = top_curve(interpolated_top_x)
- # interpolated_bottom_y = bottom_curve(interpolated_bottom_x)
- # middle_curve_point_x = (interpolated_top_x + interpolated_bottom_x) / 2
- # middle_curve_point_y = (interpolated_top_y + interpolated_bottom_y) / 2
- #
- # # fill character center list from middle curve information
- # for c in range(len(self.transcription)):
- # chars.append(((middle_curve_point_x[c] + middle_curve_point_x[c+1])/2,
- # (middle_curve_point_y[c] + middle_curve_point_y[c+1])/2))
- #
- # return chars
-
diff --git a/cleval/__init__.py b/cleval/__init__.py
new file mode 100644
index 0000000..a6f768e
--- /dev/null
+++ b/cleval/__init__.py
@@ -0,0 +1,5 @@
+from .torchmetric import CLEvalMetric
+
+__version__ = ["0.1.1"]
+
+__all__ = ["CLEvalMetric"]
diff --git a/cleval/arg_parser.py b/cleval/arg_parser.py
new file mode 100644
index 0000000..b2eab9d
--- /dev/null
+++ b/cleval/arg_parser.py
@@ -0,0 +1,89 @@
+import argparse
+import os
+
+from cleval.utils import cpu_count
+
+
+def str2bool(v):
+ if isinstance(v, bool):
+ return v
+ if v.lower() in ("yes", "true", "t", "y", "1"):
+ return True
+ elif v.lower() in ("no", "false", "f", "n", "0"):
+ return False
+ else:
+ raise argparse.ArgumentTypeError("Boolean value expected.")
+
+
+def get_params():
+ parser = argparse.ArgumentParser(description="test global argument parser")
+
+ # script parameters
+ parser.add_argument("-g", "--GT_PATHS", nargs="+", help="Path of the Ground Truth files.")
+ parser.add_argument("-s", "--SUBMIT_PATHS", nargs="+", help="Path of your method's results file.")
+
+ # webserver parameters
+ parser.add_argument(
+ "-o",
+ "--OUTPUT_PATH",
+ default="output/",
+ help="Path to a directory where to copy the file that" " contains per-sample results.",
+ )
+ parser.add_argument("--DUMP_SAMPLE_RESULT", action="store_true")
+ parser.add_argument("-p", "--PORT", default=8080, help="port number to show")
+
+ # result format related parameters
+ parser.add_argument("--BOX_TYPE", default="QUAD", choices=["LTRB", "QUAD", "POLY"])
+ parser.add_argument("--TRANSCRIPTION", action="store_true")
+ parser.add_argument("--CONFIDENCES", action="store_true")
+ parser.add_argument("--CRLF", action="store_true")
+
+ # end-to-end related parameters
+ parser.add_argument("--E2E", action="store_true")
+ parser.add_argument("--CASE_SENSITIVE", default=True, type=str2bool)
+ parser.add_argument("--RECOG_SCORE", default=True, type=str2bool)
+
+ # evaluation related parameters
+ parser.add_argument("--AREA_PRECISION_CONSTRAINT", type=float, default=0.3)
+ parser.add_argument("--RECALL_GRANULARITY_PENALTY_WEIGHT", type=float, default=1.0)
+ parser.add_argument("--PRECISION_GRANULARITY_PENALTY_WEIGHT", type=float, default=1.0)
+ parser.add_argument("--VERTICAL_ASPECT_RATIO_THRESH", default=0.5)
+
+ # orientation evaluation
+ parser.add_argument("--ORIENTATION", action="store_true")
+
+ # scale-wise evaluation (
+ parser.add_argument("--SCALE_WISE", action="store_true") # scale-wise evaluation
+ parser.add_argument("--SCALE_BINS", default=(0.0, 0.005, 0.01, 0.015, 0.02, 0.025, 0.1, 0.5, 1.0))
+
+ # other parameters
+ parser.add_argument("-t", "--NUM_WORKERS", default=-1, type=int, help="number of threads to use")
+ parser.add_argument(
+ "-v",
+ "--VERBOSE",
+ default=False,
+ action="store_true",
+ help="print evaluation progress or not",
+ )
+ parser.add_argument("--DEBUG", action="store_true")
+ parser.add_argument("--PROFILE", action="store_true")
+
+ args = parser.parse_args()
+ assert len(args.GT_PATHS) == len(args.SUBMIT_PATHS) == 1
+
+ if args.NUM_WORKERS == -1:
+ args.NUM_WORKERS = cpu_count()
+
+ # We suppose there always exist transcription information on end-to-end evaluation
+ if args.E2E:
+ args.TRANSCRIPTION = True
+
+ os.makedirs(args.OUTPUT_PATH, exist_ok=True)
+ return args
+
+
+if __name__ == "__main__":
+ from pprint import pprint
+
+ args = get_params()
+ pprint(args)
diff --git a/cleval/box_types.py b/cleval/box_types.py
new file mode 100644
index 0000000..6c43fcc
--- /dev/null
+++ b/cleval/box_types.py
@@ -0,0 +1,386 @@
+import abc
+import math
+
+import cv2
+import numpy as np
+import Polygon as polygon3
+from shapely.geometry import Point
+from shapely.geometry import Polygon as shapely_poly
+
+MAX_FIDUCIAL_POINTS = 50
+
+
+def get_midpoints(p1, p2):
+ return (p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2
+
+
+def point_distance(p1, p2):
+ distx = math.fabs(p1[0] - p2[0])
+ disty = math.fabs(p1[1] - p2[1])
+ return math.sqrt(distx * distx + disty * disty)
+
+
+class Box(metaclass=abc.ABCMeta):
+ def __init__(
+ self,
+ points,
+ confidence,
+ transcription,
+ orientation=None,
+ is_dc=None,
+ ):
+ self.points = points
+ self.confidence = confidence
+ self.transcription = transcription
+ self.orientation = orientation
+ self.is_dc = transcription == "###" if is_dc is None else is_dc
+
+ @abc.abstractmethod
+ def __and__(self, other) -> float:
+ """Returns intersection between two objects"""
+ pass
+
+ @abc.abstractmethod
+ def subtract(self, other):
+ """polygon subtraction"""
+ pass
+
+ @abc.abstractmethod
+ def center(self):
+ pass
+
+ @abc.abstractmethod
+ def center_distance(self, other):
+ """center distance between each box"""
+
+ @abc.abstractmethod
+ def diagonal_length(self) -> float:
+ """Returns diagonal length for box-level"""
+ pass
+
+ @abc.abstractmethod
+ def is_inside(self, x, y) -> bool:
+ """Returns point (x, y) is inside polygon."""
+ pass
+
+ @abc.abstractmethod
+ def make_polygon_obj(self):
+ # TODO: docstring 좀 더 자세히 적기
+ """Make polygon object to calculate for future"""
+ pass
+
+ @abc.abstractmethod
+ def pseudo_character_center(self, *args) -> list:
+ """get character level boxes for TedEval pseudo center"""
+ pass
+
+
+class QUAD(Box):
+ """Points should be x1,y1,...,x4,y4 (8 points) format"""
+
+ def __init__(
+ self,
+ points,
+ confidence=0.0,
+ transcription="",
+ orientation=None,
+ is_dc=None,
+ scale=None,
+ ):
+ super().__init__(points, confidence, transcription, orientation, is_dc)
+ self.polygon = self.make_polygon_obj()
+ self.scale = scale
+ if self.is_dc:
+ self.transcription = "#" * self.pseudo_transcription_length()
+
+ def __and__(self, other) -> float:
+ """Get intersection between two area"""
+ poly_intersect = self.polygon & other.polygon
+ if len(poly_intersect) == 0:
+ return 0.0
+ return poly_intersect.area()
+
+ def subtract(self, other):
+ self.polygon = self.polygon - other.polygon
+
+ def center(self):
+ return self.polygon.center()
+
+ def center_distance(self, other):
+ return point_distance(self.center(), other.center())
+
+ def area(self):
+ return self.polygon.area()
+
+ def __or__(self, other):
+ return self.polygon.area() + other.polygon.area() - (self & other)
+
+ def make_polygon_obj(self):
+ point_matrix = np.empty((4, 2), np.int32)
+ point_matrix[0][0] = int(self.points[0])
+ point_matrix[0][1] = int(self.points[1])
+ point_matrix[1][0] = int(self.points[2])
+ point_matrix[1][1] = int(self.points[3])
+ point_matrix[2][0] = int(self.points[4])
+ point_matrix[2][1] = int(self.points[5])
+ point_matrix[3][0] = int(self.points[6])
+ point_matrix[3][1] = int(self.points[7])
+ return polygon3.Polygon(point_matrix)
+
+ def aspect_ratio(self):
+ top_side = point_distance((self.points[0], self.points[1]), (self.points[2], self.points[3]))
+ right_side = point_distance((self.points[2], self.points[3]), (self.points[4], self.points[5]))
+ bottom_side = point_distance((self.points[4], self.points[5]), (self.points[6], self.points[7]))
+ left_side = point_distance((self.points[6], self.points[7]), (self.points[0], self.points[1]))
+ avg_hor = (top_side + bottom_side) / 2
+ avg_ver = (right_side + left_side) / 2
+
+ return (avg_hor + 1e-5) / (avg_ver + 1e-5)
+
+ def pseudo_transcription_length(self):
+ return min(round(0.5 + (max(self.aspect_ratio(), 1 / self.aspect_ratio()))), 10)
+
+ def pseudo_character_center(self, vertical_aspect_ratio_threshold):
+ chars = list()
+ length = len(self.transcription)
+ aspect_ratio = self.aspect_ratio()
+
+ if length == 0:
+ return chars
+
+ if aspect_ratio >= vertical_aspect_ratio_threshold:
+ left_top = self.points[0], self.points[1]
+ right_top = self.points[2], self.points[3]
+ right_bottom = self.points[4], self.points[5]
+ left_bottom = self.points[6], self.points[7]
+ else:
+ left_top = self.points[6], self.points[7]
+ right_top = self.points[0], self.points[1]
+ right_bottom = self.points[2], self.points[3]
+ left_bottom = self.points[4], self.points[5]
+
+ p1 = get_midpoints(left_top, left_bottom)
+ p2 = get_midpoints(right_top, right_bottom)
+
+ unit_x = (p2[0] - p1[0]) / length
+ unit_y = (p2[1] - p1[1]) / length
+
+ for i in range(length):
+ x = p1[0] + unit_x / 2 + unit_x * i
+ y = p1[1] + unit_y / 2 + unit_y * i
+ chars.append((x, y))
+ return chars
+
+ def diagonal_length(self) -> float:
+ left_top = self.points[0], self.points[1]
+ right_top = self.points[2], self.points[3]
+ right_bottom = self.points[4], self.points[5]
+ left_bottom = self.points[6], self.points[7]
+ diag1 = point_distance(left_top, right_bottom)
+ diag2 = point_distance(right_top, left_bottom)
+ return (diag1 + diag2) / 2
+
+ def is_inside(self, x, y) -> bool:
+ return self.polygon.isInside(x, y)
+
+
+class POLY(Box):
+ """Points should be x1,y1,...,xn,yn (2*n points) format"""
+
+ def __init__(self, points, confidence=0.0, transcription="", orientation=None, is_dc=None):
+ super().__init__(points, confidence, transcription, orientation, is_dc)
+ self.num_points = len(self.points) // 2
+ self.polygon = self.make_polygon_obj()
+ self._aspect_ratio = self.make_aspect_ratio()
+ if self.is_dc:
+ self.transcription = "#" * self.pseudo_transcription_length()
+
+ def __and__(self, other):
+ """Get intersection between two area"""
+ poly_intersect = self.polygon.intersection(other.polygon)
+ return poly_intersect.area
+
+ def subtract(self, other):
+ """get substraction"""
+ self.polygon = self.polygon.difference(self.polygon.intersection(other.polygon))
+
+ def __or__(self, other):
+ return 1.0
+
+ def area(self):
+ return self.polygon.area
+
+ def center(self):
+ return self.polygon.centroid.coords[0]
+
+ def center_distance(self, other):
+ try:
+ return point_distance(self.center(), other.center())
+ except:
+ return 0.0001
+
+ def diagonal_length(self):
+ left_top = self.points[0], self.points[1]
+ right_top = self.points[self.num_points - 2], self.points[self.num_points - 1]
+ right_bottom = self.points[self.num_points], self.points[self.num_points + 1]
+ left_bottom = (
+ self.points[self.num_points * 2 - 2],
+ self.points[self.num_points * 2 - 1],
+ )
+
+ diag1 = point_distance(left_top, right_bottom)
+ diag2 = point_distance(right_top, left_bottom)
+
+ return (diag1 + diag2) / 2
+
+ def is_inside(self, x, y) -> bool:
+ return self.polygon.contains(Point(x, y))
+
+ def check_corner_points_are_continuous(self, lt, rt, rb, lb):
+ counter = 0
+ while lt != rt:
+ lt = (lt + 1) % self.num_points
+ counter += 1
+
+ while rb != lb:
+ rb = (rb + 1) % self.num_points
+ counter += 1
+
+ return True
+
+ def get_four_max_distance_from_center(self):
+ center_x, center_y = self.center()
+ distance_from_center = list()
+ point_x = self.points[0::2]
+ point_y = self.points[1::2]
+
+ for px, py in zip(point_x, point_y):
+ distance_from_center.append(point_distance((center_x, center_y), (px, py)))
+
+ distance_idx_max_order = np.argsort(distance_from_center)[::-1]
+ return distance_idx_max_order[:4]
+
+ def make_polygon_obj(self):
+ point_x = self.points[0::2]
+ point_y = self.points[1::2]
+ # In TotalText dataset, there are under 4 points annotation for Polygon shape.
+ # so, we have to deal with it
+
+ # if points are given 3, fill last quad points with left bottom coordinates
+ if len(point_x) == len(point_y) == 3:
+ point_x.append(point_x[0])
+ point_y.append(point_y[2])
+ self.points.append(point_x[0])
+ self.points.append(point_y[2])
+ self.num_points = len(self.points) // 2
+
+ # if points are given 2, copy value 2 times
+ elif len(point_x) == len(point_y) == 2:
+ point_x *= 2
+ point_y *= 2
+ self.points.append(point_x[1])
+ self.points.append(point_y[0])
+ self.points.append(point_x[0])
+ self.points.append(point_y[1])
+ self.num_points = len(self.points) // 2
+
+ # if points are given 1, copy value 4 times
+ elif len(point_x) == len(point_y) == 1:
+ point_x *= 4
+ point_y *= 4
+ for _ in range(3):
+ self.points.append(point_x[0])
+ self.points.append(point_x[0])
+ self.num_points = len(self.points) // 2
+ return shapely_poly(np.stack([point_x, point_y], axis=1)).buffer(0)
+
+ def aspect_ratio(self):
+ return self._aspect_ratio
+
+ def pseudo_transcription_length(self):
+ return min(round(0.5 + (max(self._aspect_ratio, 1 / self._aspect_ratio))), 10)
+
+ def make_aspect_ratio(self):
+ np.array(np.reshape(self.points, [-1, 2]))
+ rect = cv2.minAreaRect(np.array(np.reshape(self.points, [-1, 2]), dtype=np.float32))
+ width = rect[1][0]
+ height = rect[1][1]
+
+ width += 1e-6
+ height += 1e-6
+
+ return min(10, height / width) + 1e5
+
+ def pseudo_character_center(self):
+ chars = list()
+ length = len(self.transcription)
+
+ # Prepare polygon line estimation with interpolation
+ point_x = self.points[0::2]
+ point_y = self.points[1::2]
+ points_x_top = point_x[: self.num_points // 2]
+ points_x_bottom = point_x[self.num_points // 2 :]
+ points_y_top = point_y[: self.num_points // 2]
+ points_y_bottom = point_y[self.num_points // 2 :]
+
+ # reverse bottom point order from left to right
+ points_x_bottom = points_x_bottom[::-1]
+ points_y_bottom = points_y_bottom[::-1]
+
+ num_interpolation_section = (self.num_points // 2) - 1
+ num_points_to_interpolate = length
+
+ new_point_x_top, new_point_x_bottom = list(), list()
+ new_point_y_top, new_point_y_bottom = list(), list()
+
+ for sec_idx in range(num_interpolation_section):
+ start_x_top, end_x_top = points_x_top[sec_idx], points_x_top[sec_idx + 1]
+ start_y_top, end_y_top = points_y_top[sec_idx], points_y_top[sec_idx + 1]
+ start_x_bottom, end_x_bottom = (
+ points_x_bottom[sec_idx],
+ points_x_bottom[sec_idx + 1],
+ )
+ start_y_bottom, end_y_bottom = (
+ points_y_bottom[sec_idx],
+ points_y_bottom[sec_idx + 1],
+ )
+
+ diff_x_top = (end_x_top - start_x_top) / num_points_to_interpolate
+ diff_y_top = (end_y_top - start_y_top) / num_points_to_interpolate
+ diff_x_bottom = (end_x_bottom - start_x_bottom) / num_points_to_interpolate
+ diff_y_bottom = (end_y_bottom - start_y_bottom) / num_points_to_interpolate
+
+ new_point_x_top.append(start_x_top)
+ new_point_x_bottom.append(start_x_bottom)
+ new_point_y_top.append(start_y_top)
+ new_point_y_bottom.append(start_y_bottom)
+
+ for num_pt in range(1, num_points_to_interpolate):
+ new_point_x_top.append(int(start_x_top + diff_x_top * num_pt))
+ new_point_x_bottom.append(int(start_x_bottom + diff_x_bottom * num_pt))
+ new_point_y_top.append(int(start_y_top + diff_y_top * num_pt))
+ new_point_y_bottom.append(int(start_y_bottom + diff_y_bottom * num_pt))
+ new_point_x_top.append(points_x_top[-1])
+ new_point_y_top.append(points_y_top[-1])
+ new_point_x_bottom.append(points_x_bottom[-1])
+ new_point_y_bottom.append(points_y_bottom[-1])
+
+ len_section_for_single_char = (len(new_point_x_top) - 1) / len(self.transcription)
+
+ for c in range(len(self.transcription)):
+ center_x = (
+ new_point_x_top[int(c * len_section_for_single_char)]
+ + new_point_x_top[int((c + 1) * len_section_for_single_char)]
+ + new_point_x_bottom[int(c * len_section_for_single_char)]
+ + new_point_x_bottom[int((c + 1) * len_section_for_single_char)]
+ ) / 4
+
+ center_y = (
+ new_point_y_top[int(c * len_section_for_single_char)]
+ + new_point_y_top[int((c + 1) * len_section_for_single_char)]
+ + new_point_y_bottom[int(c * len_section_for_single_char)]
+ + new_point_y_bottom[int((c + 1) * len_section_for_single_char)]
+ ) / 4
+
+ chars.append((center_x, center_y))
+ return chars
diff --git a/cleval/data.py b/cleval/data.py
new file mode 100644
index 0000000..78e25a7
--- /dev/null
+++ b/cleval/data.py
@@ -0,0 +1,152 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Union
+
+from cleval.utils import harmonic_mean
+
+
+class MatchReleation:
+ ONE_TO_ONE = "one-to-one"
+ MANY_TO_ONE = "many-to-one"
+ ONE_TO_MANY = "one-to-many"
+
+
+@dataclass
+class CoreStats:
+ recall: float = 0.0
+ precision: float = 0.0
+ hmean: float = 0.0
+
+ num_char_gt: int = 0 # TotalNum for Recall
+ num_char_det: int = 0 # TotalNum for Precisiion
+ gran_score_recall: float = 0.0
+ num_char_tp_recall: int = 0
+ gran_score_precision: float = 0.0
+ num_char_tp_precision: int = 0
+
+ num_char_fp: int = 0 # false positive
+
+
+@dataclass
+class MatchResult:
+ gt_ids: List[int]
+ det_ids: List[int]
+ match_relation: str # from MatchRelation
+
+ det: CoreStats = field(default_factory=CoreStats)
+ e2e: CoreStats = field(default_factory=CoreStats)
+
+
+@dataclass
+class Point:
+ x: int
+ y: int
+
+
+@dataclass
+class GTBoxResult:
+ id: int
+ points: List[Point]
+ pccs: List[Point]
+ orientation: Union[None, str]
+ letters: str
+ is_dc: bool
+
+
+@dataclass
+class DetBoxResult:
+ id: int
+ points: List[Point]
+ orientation: Union[None, str]
+ letters: str
+
+
+@dataclass
+class Stats:
+ det: CoreStats = field(default_factory=CoreStats)
+ e2e: CoreStats = field(default_factory=CoreStats)
+
+ # split-merge cases
+ num_splitted: int = 0
+ num_merged: int = 0
+ num_char_overlapped: int = 0
+
+ # orientation evaluation
+ ori_acc: float = 0.0
+ num_ori_total: int = 0
+ num_ori_correct: int = 0
+
+
+@dataclass
+class SampleResult:
+ matches: List[MatchResult]
+ gts: List[GTBoxResult]
+ preds: List[DetBoxResult]
+ stats: Stats = field(default_factory=Stats)
+ image_id: Union[int, None] = None
+
+
+@dataclass
+class GlobalResult:
+ """Object that holds each record of all samples."""
+
+ dataset_inform: Dict = field(default_factory=dict)
+ sample_results: List[SampleResult] = field(default_factory=list)
+ stats: Stats = field(default_factory=Stats)
+
+
+def accumulate_result(
+ global_res: GlobalResult,
+ sample_res: SampleResult,
+ is_e2e: bool,
+ dump_sample_res: bool = False,
+):
+ if dump_sample_res:
+ global_res.sample_results.append(sample_res)
+ accumulate_stats(global_res.stats, sample_res.stats, is_e2e)
+
+
+def accumulate_stats(stats1: Stats, stats2: Stats, is_e2e: bool):
+ """Accumulate core stats exclude ori_acc."""
+ stats1.num_splitted += stats2.num_splitted
+ stats1.num_merged += stats2.num_merged
+ stats1.num_char_overlapped += stats2.num_char_overlapped
+ stats1.num_ori_total += stats2.num_ori_total
+ stats1.num_ori_correct += stats2.num_ori_correct
+
+ accumulate_core_stats(stats1.det, stats2.det)
+ if is_e2e:
+ accumulate_core_stats(stats1.e2e, stats2.e2e)
+
+
+def accumulate_core_stats(stats1: CoreStats, stats2: CoreStats):
+ """Accumulate core stats exclude recall, precision, and hmean."""
+ stats1.num_char_gt += stats2.num_char_gt
+ stats1.num_char_det += stats2.num_char_det
+ stats1.gran_score_recall += stats2.gran_score_recall
+ stats1.num_char_tp_recall += stats2.num_char_tp_recall
+ stats1.gran_score_precision += stats2.gran_score_precision
+ stats1.num_char_tp_precision += stats2.num_char_tp_precision
+ stats1.num_char_fp += stats2.num_char_fp
+
+
+def calculate_global_rph(res: GlobalResult, is_e2e: bool):
+ calculate_rph(res.stats.det)
+ if is_e2e:
+ calculate_rph(res.stats.e2e)
+
+
+def calculate_rph(stats: CoreStats):
+ total_gt = stats.num_char_gt
+ total_det = stats.num_char_det
+ tp_gt = stats.num_char_tp_recall
+ gran_gt = stats.gran_score_recall
+ tp_det = stats.num_char_tp_precision
+ gran_det = stats.gran_score_precision
+
+ # Sample Score : Character correct length - Granularity Penalty
+ recall = 0.0 if total_gt == 0 else max(0.0, tp_gt - gran_gt) / total_gt
+ precision = 0.0 if total_det == 0 else max(0.0, tp_det - gran_det) / total_det
+ hmean = harmonic_mean(recall, precision)
+ stats.recall = recall
+ stats.precision = precision
+ stats.hmean = hmean
diff --git a/cleval/eval_functions.py b/cleval/eval_functions.py
new file mode 100644
index 0000000..a9b26cf
--- /dev/null
+++ b/cleval/eval_functions.py
@@ -0,0 +1,567 @@
+from dataclasses import dataclass
+from typing import List
+
+import numpy as np
+from numba import njit
+from numpy.typing import NDArray
+
+from cleval.data import (
+ DetBoxResult,
+ GTBoxResult,
+ MatchReleation,
+ MatchResult,
+ Point,
+ SampleResult,
+)
+from cleval.utils import harmonic_mean, lcs
+
+
+@dataclass
+class EvalMaterial:
+ """EvalMaterial Dataclass
+ These are used for calculating eval results.
+ """
+
+ gt_pcc_points: List[List] # [gt_idx][pcc_idx] nested list which has variable length
+ pcc_mat_list: List[NDArray] # list of pcc_mat which has (len_det, len_pcc) shape.
+ pcc_mat_sum: NDArray[np.int16] # (len_gt, len_det)
+ ap_mat: NDArray[np.float32] # (len_gt, len_det)
+ ap_mat_binary: NDArray[bool] # (len_gt, len_det)
+ ap_constraint: float
+ gt_valid_indices: set
+ det_valid_indices: set
+ len_gt: int
+ len_det: int
+
+
+def evaluation(args, gt_boxes, det_boxes, scale_range=(0.0, 1.0)):
+ """main evaluation function
+
+ Notes:
+ Abbreviations for variable names.
+ - ap: area precision (not average precision)
+ - thresh: threshold
+ - pcc: pseudo char center
+ - mat: matrix
+ - res: result
+ - dc: don't care
+ - fp: false positive
+ - tran: transcription
+ """
+ # prepare gt, det
+ gt_dc_indices, gt_pcc_points = prepare_gt(
+ gt_boxes, args.CASE_SENSITIVE, args.VERTICAL_ASPECT_RATIO_THRESH, scale_range
+ )
+ prepare_det(det_boxes, args.CASE_SENSITIVE)
+ len_gt = len(gt_boxes)
+ len_det = len(det_boxes)
+
+ # calc area_precision
+ ap_constraint = args.AREA_PRECISION_CONSTRAINT
+ ap_mat, ap_mat_binary = calc_area_precision(gt_boxes, det_boxes, ap_constraint)
+
+ # calc pcc inclusion
+ pcc_mat_list, pcc_mat_sum = calc_pcc_inclusion(det_boxes, gt_pcc_points)
+
+ # prepare valid indices
+ det_dc_indices = get_det_dc_indices(gt_dc_indices, pcc_mat_sum, ap_mat, ap_mat_binary, ap_constraint, len_det)
+ gt_valid_indices = set(range(len_gt)) - gt_dc_indices
+ det_valid_indices = set(range(len_det)) - det_dc_indices
+
+ # construct eval material
+ eval_material = EvalMaterial(
+ gt_pcc_points,
+ pcc_mat_list,
+ pcc_mat_sum,
+ ap_mat,
+ ap_mat_binary,
+ ap_constraint,
+ gt_valid_indices,
+ det_valid_indices,
+ len_gt,
+ len_det,
+ )
+
+ # Matching process
+ match_mat, match_results = calc_match_matrix(eval_material)
+
+ # Prepare sample_result
+ gt_results, det_results = get_box_results(gt_boxes, gt_pcc_points, det_boxes)
+ sample_res = SampleResult(match_results, gt_results, det_results)
+
+ # Evaluation Process
+ eval_det(args, sample_res, gt_boxes, det_boxes, eval_material, match_mat)
+
+ if args.E2E:
+ eval_e2e(args, sample_res, gt_boxes, det_boxes, eval_material, match_mat)
+
+ if args.ORIENTATION:
+ eval_orientation(sample_res, gt_boxes, det_boxes, gt_valid_indices, match_mat)
+
+ return sample_res
+
+
+def prepare_gt(gt_boxes, is_case_sensitive, vertical_aspect_ratio_thresh, scale_range):
+ """prepare ground-truth boxes in evaluation format."""
+ gt_dc_indices = set() # fast check via using set (hash-table)
+ gt_pcc_points = []
+ for gt_idx, gt_box in enumerate(gt_boxes):
+ if not is_case_sensitive:
+ gt_box.transcription = gt_box.transcription.upper()
+
+ if gt_box.is_dc or (gt_box.scale is not None and not scale_range[0] <= gt_box.scale <= scale_range[1]):
+ gt_dc_indices.add(gt_idx)
+ gt_pcc_point = gt_box.pseudo_character_center(vertical_aspect_ratio_thresh)
+ gt_pcc_points.append(gt_pcc_point)
+
+ # subtract overlapping gt area from don't care boxes
+ # Area(Don't care) - Area(Ground Truth):
+ for dc_idx in gt_dc_indices:
+ for idx in range(len(gt_boxes)):
+ if idx in gt_dc_indices:
+ continue
+ if gt_boxes[idx] & gt_boxes[dc_idx] > 0:
+ # TODO: Consider PCC exclusion for area overlapped with don't care.
+ gt_boxes[dc_idx].subtract(gt_boxes[idx])
+ return gt_dc_indices, gt_pcc_points
+
+
+def prepare_det(det_boxes, is_case_sensitive):
+ """prepare detection results in evaluation format."""
+ for det_idx, det_box in enumerate(det_boxes):
+ if not is_case_sensitive:
+ det_box.transcription = det_box.transcription.upper()
+
+
+def calc_area_precision(gt_boxes, det_boxes, ap_constraint):
+ """calculate area precision between each GTbox and DETbox
+ Args:
+ gt_boxes(List[Box]): list of gt boxes
+ det_boxes(List[Box]): list of det boxes
+ ap_constraint(float): area precision contstraint
+
+ Returns:
+ ap_mat(NDArray[float32]): area precision matrix
+ ap_mat_binary(NDArray[bool]): boolean mat that area precision >= ap_constraint
+
+ """
+ ap_mat = np.zeros([len(gt_boxes), len(det_boxes)], dtype=np.float32)
+
+ for gt_idx, gt_box in enumerate(gt_boxes):
+ for det_idx, det_box in enumerate(det_boxes):
+ intersected_area = gt_box & det_box
+ det_area = det_box.area()
+ if det_area > 0.0:
+ ap_mat[gt_idx, det_idx] = intersected_area / det_area
+ ap_mat_binary = ap_mat >= ap_constraint
+ return ap_mat, ap_mat_binary
+
+
+def calc_pcc_inclusion(det_boxes, gt_pcc_points):
+ """fill PCC counting matrix by iterating each GTbox and DETbox"""
+ len_gt = len(gt_pcc_points)
+ len_det = len(det_boxes)
+ pcc_mat_list = []
+ pcc_mat_sum = np.zeros((len_gt, len_det), dtype=np.int16)
+
+ for gt_idx, gt_word_pccs in enumerate(gt_pcc_points):
+ len_pcc = len(gt_word_pccs)
+ pcc_mat = np.zeros((len_det, len_pcc), dtype=bool)
+
+ for det_idx, det_box in enumerate(det_boxes):
+ for pcc_idx, pcc_point in enumerate(gt_word_pccs):
+ if det_box.is_inside(pcc_point[0], pcc_point[1]):
+ pcc_mat[det_idx, pcc_idx] = True
+ pcc_mat_sum[gt_idx, det_idx] += 1
+
+ pcc_mat_list.append(pcc_mat)
+ return pcc_mat_list, pcc_mat_sum
+
+
+def get_det_dc_indices(gt_dc_indices, pcc_mat_sum, ap_mat, ap_mat_binary, ap_constraint, len_det):
+ """Filter detection Don't care boxes"""
+ det_dc_indices = set()
+ if len(gt_dc_indices) > 0:
+ for det_idx in range(len_det):
+ ap_sum = 0
+ for gt_idx in gt_dc_indices:
+ if ap_mat_binary[gt_idx, det_idx]:
+ det_dc_indices.add(det_idx)
+ break
+ if pcc_mat_sum[gt_idx, det_idx] > 0:
+ ap_sum += ap_mat[gt_idx, det_idx]
+ if ap_sum >= ap_constraint:
+ det_dc_indices.add(det_idx)
+ return det_dc_indices
+
+
+def calc_match_matrix(eval_material):
+ """Calculate match matrix with PCC counting matrix information."""
+ em = eval_material
+ match_results = []
+ match_mat = np.zeros([em.len_gt, em.len_det], dtype=bool)
+
+ # one-to-one match
+ for gt_idx in em.gt_valid_indices:
+ for det_idx in em.det_valid_indices:
+ is_matched = one_to_one_match(em.pcc_mat_sum, gt_idx, det_idx, em.ap_mat_binary, em.len_gt, em.len_det)
+ if is_matched:
+ match_result = MatchResult(
+ gt_ids=[gt_idx],
+ det_ids=[det_idx],
+ match_relation=MatchReleation.ONE_TO_ONE,
+ )
+ match_results.append(match_result)
+
+ # one-to-many match
+ for gt_idx in em.gt_valid_indices:
+ det_valid_indices_np = np.array(list(em.det_valid_indices), dtype=np.int16)
+ is_matched, matched_det_indices = one_to_many_match(
+ em.pcc_mat_sum, gt_idx, em.ap_mat_binary, det_valid_indices_np
+ )
+ if is_matched:
+ match_result = MatchResult(
+ gt_ids=[gt_idx],
+ det_ids=matched_det_indices,
+ match_relation=MatchReleation.ONE_TO_MANY,
+ )
+ match_results.append(match_result)
+
+ # many-to-one match
+ for det_idx in em.det_valid_indices:
+ gt_valid_indices_np = np.array(list(em.gt_valid_indices), dtype=np.int16)
+ is_matched, matched_gt_indices = many_to_one_match(
+ em.pcc_mat_sum, det_idx, em.ap_mat, em.ap_constraint, gt_valid_indices_np
+ )
+ if is_matched:
+ match_result = MatchResult(
+ gt_ids=matched_gt_indices,
+ det_ids=[det_idx],
+ match_relation=MatchReleation.MANY_TO_ONE,
+ )
+ match_results.append(match_result)
+
+ for match_result in match_results:
+ match_mat[match_result.gt_ids, match_result.det_ids] = True
+
+ # clear pcc count flag for not matched pairs
+ for gt_idx in range(em.len_gt):
+ for det_idx in range(em.len_det):
+ if match_mat[gt_idx, det_idx]:
+ continue
+ for pcc_idx in range(len(em.gt_pcc_points[gt_idx])):
+ em.pcc_mat_sum[gt_idx, det_idx] -= em.pcc_mat_list[gt_idx][det_idx, pcc_idx]
+ em.pcc_mat_list[gt_idx][det_idx, pcc_idx] = 0
+ return match_mat, match_results
+
+
+@njit
+def one_to_one_match(pcc_mat_sum, gt_idx, det_idx, ap_mat_binary, len_gt, len_det):
+ """One-to-One match condition"""
+ match_counter = 0
+ for i in range(len_det):
+ if ap_mat_binary[gt_idx, i] and pcc_mat_sum[gt_idx, i] > 0:
+ match_counter += 1
+ if match_counter >= 2:
+ break
+ if match_counter != 1:
+ return False
+
+ match_counter = 0
+ for i in range(len_gt):
+ if ap_mat_binary[i, det_idx] and pcc_mat_sum[i, det_idx] > 0:
+ match_counter += 1
+ if match_counter >= 2:
+ break
+ if match_counter != 1:
+ return False
+
+ if ap_mat_binary[gt_idx, det_idx] and pcc_mat_sum[gt_idx, det_idx] > 0:
+ return True
+ return False
+
+
+@njit
+def one_to_many_match(pcc_mat_sum, gt_idx, ap_mat_binary, det_valid_indices):
+ """One-to-Many match condition"""
+ many_sum = 0
+ matched_det_indices = []
+ for det_idx in det_valid_indices:
+ if ap_mat_binary[gt_idx, det_idx] and pcc_mat_sum[gt_idx, det_idx] > 0:
+ many_sum += pcc_mat_sum[gt_idx, det_idx]
+ matched_det_indices.append(det_idx)
+
+ if many_sum > 0 and len(matched_det_indices) >= 2:
+ return True, matched_det_indices
+ else:
+ return False, matched_det_indices
+
+
+@njit
+def many_to_one_match(pcc_mat_sum, det_idx, ap_mat, ap_constraint, gt_valid_indices):
+ """Many-to-One match condition"""
+ many_sum = 0
+ matched_gt_indices = []
+ for gt_idx in gt_valid_indices:
+ if pcc_mat_sum[gt_idx, det_idx] > 0:
+ many_sum += ap_mat[gt_idx, det_idx]
+ matched_gt_indices.append(gt_idx)
+ if many_sum >= ap_constraint and len(matched_gt_indices) >= 2:
+ return True, matched_gt_indices
+ else:
+ return False, matched_gt_indices
+
+
+def get_box_results(gt_boxes, gt_pcc_points, det_boxes):
+ gt_results = []
+ for gt_idx, gt_box in enumerate(gt_boxes):
+ gt = GTBoxResult(
+ id=gt_idx,
+ points=__points_to_result(gt_box.points),
+ pccs=__pccs_to_result(gt_pcc_points[gt_idx]),
+ orientation=gt_box.orientation,
+ letters=gt_box.transcription,
+ is_dc=gt_box.is_dc,
+ )
+ gt_results.append(gt)
+
+ det_results = []
+ for det_idx, det_box in enumerate(det_boxes):
+ det = DetBoxResult(
+ id=det_idx,
+ points=__points_to_result(det_box.points),
+ orientation=det_box.orientation,
+ letters=det_box.transcription,
+ )
+ det_results.append(det)
+
+ return gt_results, det_results
+
+
+def __points_to_result(points):
+ points = np.array(points, dtype=np.int16).reshape(-1, 2)
+ new_points = [Point(int(round(pt[0])), int(round(pt[1]))) for pt in points]
+ return new_points
+
+
+def __pccs_to_result(pcc_points):
+ return [Point(int(round(pt[0])), int(round(pt[1]))) for pt in pcc_points]
+
+
+def eval_det(args, sample_res, gt_boxes, det_boxes, eval_material, match_mat):
+ stats = sample_res.stats
+ em = eval_material
+
+ # res_mat has +2 size for granuarity penalty and summation of matrix
+ res_mat = np.zeros([em.len_gt + 2, em.len_det + 2], dtype=np.float32)
+
+ match_mat_gts_sum = match_mat.sum(axis=0)
+ match_mat_dets_sum = match_mat.sum(axis=1)
+ pcc_checked = [np.zeros(len(pccs), dtype=bool) for pccs in em.gt_pcc_points]
+
+ # Precision score
+ for det_idx in em.det_valid_indices:
+ if match_mat_gts_sum[det_idx] > 0:
+ matched_gt_indices = np.where(match_mat[:, det_idx])[0]
+ if len(matched_gt_indices) > 1:
+ stats.num_merged += 1
+
+ for gt_idx in matched_gt_indices:
+ pcc_indices = np.where(em.pcc_mat_list[gt_idx][det_idx])[0]
+ for pcc_idx in pcc_indices:
+ if not pcc_checked[gt_idx][pcc_idx]:
+ pcc_checked[gt_idx][pcc_idx] = True
+ res_mat[-2, det_idx] += 1 # for total score
+ res_mat[gt_idx, det_idx] += 1
+ else:
+ stats.num_char_overlapped += 1
+ gran_weight = args.PRECISION_GRANULARITY_PENALTY_WEIGHT
+ res_mat[-1, det_idx] = get_gran_score(len(matched_gt_indices), gran_weight)
+
+ # Recall score
+ for gt_idx in em.gt_valid_indices:
+ found_gt_chars = 0
+ if match_mat_dets_sum[gt_idx] > 0:
+ matched_det_indices = np.where(match_mat[gt_idx] > 0)[0]
+ if len(matched_det_indices) > 1:
+ stats.num_splitted += 1
+
+ found_gt_chars = np.sum(pcc_checked[gt_idx])
+ gran_weight = args.RECALL_GRANULARITY_PENALTY_WEIGHT
+ res_mat[gt_idx, -1] = get_gran_score(len(matched_det_indices), gran_weight)
+ res_mat[gt_idx, -2] = found_gt_chars
+
+ # Calculate precision / recall
+ num_char_gt, num_char_det = get_num_total_char(gt_boxes, em.pcc_mat_sum, em.gt_valid_indices, em.det_valid_indices)
+ num_char_fp = get_num_fp_char(det_boxes, em.det_valid_indices, match_mat_gts_sum)
+ num_char_det += num_char_fp
+ extract_stats(sample_res.stats.det, num_char_fp, num_char_gt, num_char_det, res_mat)
+
+ # Calculate match-wise eval out
+ if args.DUMP_SAMPLE_RESULT:
+ for match_res in sample_res.matches:
+ gt_ids = match_res.gt_ids
+ det_ids = match_res.det_ids
+ num_char_gt, num_char_det = get_num_total_char(gt_boxes, em.pcc_mat_sum, gt_ids, det_ids)
+ num_char_fp = get_num_fp_char(det_boxes, det_ids, match_mat_gts_sum)
+ num_char_det += num_char_fp
+ extract_stats(match_res.det, num_char_fp, num_char_gt, num_char_det, res_mat)
+
+
+def get_num_total_char(gt_boxes, pcc_mat_sum, gt_valid_indices, det_valid_indices):
+ """get TotalNum for detection evaluation."""
+ num_char_gt = 0
+ num_char_det = 0
+ for gt_idx, gt_box in enumerate(gt_boxes):
+ if gt_idx in gt_valid_indices:
+ num_char_gt += len(gt_box.transcription)
+ num_char_det += np.sum(pcc_mat_sum[gt_idx][list(det_valid_indices)])
+ return num_char_gt, num_char_det
+
+
+def get_num_fp_char(det_boxes, det_valid_indices, match_mat_gts_sum):
+ """get FalsePositive for detection evaluation."""
+ fp_char_counts = 0
+ for det_idx in det_valid_indices:
+ # no match with any GTs && not matched with don't care
+ if match_mat_gts_sum[det_idx] == 0:
+ fp_char_count = round(0.5 + 1 / (1e-5 + det_boxes[det_idx].aspect_ratio()))
+ fp_char_counts += min(fp_char_count, 10)
+ return fp_char_counts
+
+
+def eval_e2e(args, sample_res, gt_boxes, det_boxes, eval_material, match_mat):
+ gt_trans = [box.transcription for box in gt_boxes]
+ det_trans = [box.transcription for box in det_boxes]
+ gt_trans_not_found = [box.transcription for box in gt_boxes]
+ det_trans_not_found = [box.transcription for box in det_boxes]
+
+ em = eval_material
+ stats = sample_res.stats
+
+ # +2 size for granuarity penalty and summation of matrix
+ res_mat = np.zeros([em.len_gt + 2, em.len_det + 2], dtype=np.float32)
+
+ match_mat_gts_sum = match_mat.sum(axis=0)
+ match_mat_dets_sum = match_mat.sum(axis=1)
+
+ # Recall score
+ for gt_idx in em.gt_valid_indices:
+ if match_mat_dets_sum[gt_idx] > 0:
+ matched_det_indices = np.where(match_mat[gt_idx])[0]
+ sorted_det_indices = sort_detbox_order_by_pcc(
+ gt_idx, matched_det_indices, em.gt_pcc_points, em.pcc_mat_list
+ )
+ corrected_num_chars = lcs_elimination(
+ gt_trans,
+ gt_trans_not_found,
+ det_trans_not_found,
+ gt_idx,
+ sorted_det_indices,
+ )
+ res_mat[gt_idx, -2] = corrected_num_chars
+ gran_weight = args.RECALL_GRANULARITY_PENALTY_WEIGHT
+ res_mat[gt_idx, -1] = get_gran_score(len(matched_det_indices), gran_weight)
+
+ # Precision score
+ for det_idx in em.det_valid_indices:
+ if match_mat_gts_sum[det_idx] > 0:
+ matched_gt_indices = np.where(match_mat[:, det_idx])[0]
+ gran_weight = args.PRECISION_GRANULARITY_PENALTY_WEIGHT
+ res_mat[-1, det_idx] = get_gran_score(len(matched_gt_indices), gran_weight)
+ res_mat[-2, det_idx] = len(det_trans[det_idx]) - len(det_trans_not_found[det_idx])
+
+ num_char_det = sum([len(det_trans[i]) for i in em.det_valid_indices])
+ num_char_fp = num_char_det - np.sum(res_mat[-2])
+ extract_stats(stats.e2e, num_char_fp, stats.det.num_char_gt, num_char_det, res_mat)
+
+ if args.DUMP_SAMPLE_RESULT:
+ for match_res in sample_res.matches:
+ det_ids = match_res.det_ids
+ num_char_det = sum([len(det_trans[i]) for i in det_ids])
+ num_char_fp = num_char_det - np.sum(res_mat[-2][det_ids])
+ num_char_gt = match_res.det.num_char_gt
+ extract_stats(match_res.e2e, num_char_fp, num_char_gt, num_char_det, res_mat)
+
+
+def sort_detbox_order_by_pcc(gt_idx, matched_det_indices, gt_pcc_points, pcc_mat_list):
+ """sort detected box order by pcc information."""
+ unordered = matched_det_indices.tolist() # deepcopy
+ ordered_indices = []
+
+ char_len = len(gt_pcc_points[gt_idx])
+ for pcc_idx in range(char_len):
+ if len(unordered) == 1:
+ break
+
+ for det_idx in unordered:
+ if pcc_mat_list[gt_idx][det_idx, pcc_idx]:
+ ordered_indices.append(det_idx)
+ unordered.remove(det_idx)
+ break
+
+ ordered_indices.append(unordered[0])
+ return ordered_indices
+
+
+def lcs_elimination(gt_trans, gt_trans_not_found, det_trans_not_found, gt_idx, sorted_det_indices):
+ """longest common sequence elimination by sorted detection boxes"""
+ target_string = "".join(det_trans_not_found[i] for i in sorted_det_indices)
+ lcs_length, lcs_string = lcs(gt_trans[gt_idx], target_string)
+
+ for char in lcs_string:
+ gt_trans_not_found[gt_idx] = gt_trans_not_found[gt_idx].replace(char, "", 1)
+
+ for det_idx in sorted_det_indices:
+ det_tran = det_trans_not_found[det_idx]
+ if not det_tran.find(char) < 0:
+ det_trans_not_found[det_idx] = det_tran.replace(char, "", 1)
+ break
+ return lcs_length
+
+
+def eval_orientation(sample_res, gt_boxes, det_boxes, gt_valid_indices, match_mat):
+ gt_query = [box.orientation for box in gt_boxes]
+ det_query = [box.orientation for box in det_boxes]
+
+ match_mat_dets_sum = match_mat.sum(axis=1)
+ counter = 0
+ num_ori_correct = 0
+ stats = sample_res.stats
+
+ for gt_idx in gt_valid_indices:
+ if match_mat_dets_sum[gt_idx] > 0:
+ matched_det_indices = np.where(match_mat[gt_idx])[0]
+ counter += 1
+ count_size = 0 if len(matched_det_indices) else 1 / len(matched_det_indices)
+ for det_idx in matched_det_indices:
+ if gt_query[gt_idx] == det_query[det_idx]:
+ num_ori_correct += count_size
+ if counter != 0:
+ stats.num_ori_total = counter
+ stats.num_ori_correct = num_ori_correct
+ stats.ori_acc = num_ori_correct / counter
+
+
+def extract_stats(core_stats, num_char_fp, num_char_gt, num_char_det, res_mat):
+ core_stats.num_char_fp = int(num_char_fp)
+ core_stats.num_char_gt = total_gt = int(num_char_gt)
+ core_stats.num_char_det = total_det = int(num_char_det)
+ core_stats.num_char_tp_recall = tp_gt = int(np.sum(res_mat[-2]))
+ core_stats.gran_score_recall = gran_gt = float(np.sum(res_mat[:, -1]))
+ core_stats.num_char_tp_precision = tp_det = int(np.sum(res_mat[-2]))
+ core_stats.gran_score_precision = gran_det = float(np.sum(res_mat[-1]))
+
+ # Sample Score : Character correct length - Granularity Penalty
+ recall = 0.0 if total_gt == 0 else max(0.0, tp_gt - gran_gt) / total_gt
+ precision = 0.0 if total_det == 0 else max(0.0, tp_det - gran_det) / total_det
+ hmean = harmonic_mean(recall, precision)
+ core_stats.recall = recall
+ core_stats.precision = precision
+ core_stats.hmean = hmean
+
+
+@njit
+def get_gran_score(num_splitted, penalty_weight):
+ """get granularity penalty given number of how many splitted"""
+ return max(num_splitted - 1, 0) * penalty_weight
diff --git a/cleval/main.py b/cleval/main.py
new file mode 100644
index 0000000..f255c8f
--- /dev/null
+++ b/cleval/main.py
@@ -0,0 +1,316 @@
+import os
+import re
+import time
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import asdict
+from pprint import pprint
+
+from tqdm import tqdm
+
+from cleval.arg_parser import get_params
+from cleval.box_types import POLY, QUAD, Box
+from cleval.data import GlobalResult, accumulate_result, calculate_global_rph
+from cleval.eval_functions import evaluation
+from cleval.utils import (
+ convert_ltrb2quad,
+ decode_utf8,
+ dump_json,
+ load_zip_file,
+ ltrb_regex_match,
+ quad_regex_match,
+)
+from cleval.validation import (
+ validate_data,
+ validate_min_max_bounds,
+ validate_point_inside_bounds,
+)
+
+
+def main():
+ """Also used by cli"""
+ start_t = time.perf_counter()
+ args = get_params()
+
+ if args.PROFILE:
+ assert args.DEBUG, "DEBUG mode should be turned on for PPROFILE."
+ import pprofile
+
+ prof = pprofile.Profile()
+ with prof():
+ res_dict = cleval(args)
+ prof.print_stats()
+ else:
+ res_dict = cleval(args)
+ end_t = time.perf_counter()
+ print(f"CLEval total duration...{end_t - start_t}s")
+ pprint(res_dict)
+
+
+def cleval(args):
+ """This process validates a method, evaluates it.
+ If it succeeds, generates a ZIP file with a JSON entry for each sample.
+ """
+ validate_data(args.GT_PATHS[0], args.SUBMIT_PATHS[0], args.CRLF)
+
+ global_res = GlobalResult()
+ gt_zipfile = args.GT_PATHS[0]
+ submit_zipfile = args.SUBMIT_PATHS[0]
+ gt_files, det_files, file_indices = get_file_paths(gt_zipfile, submit_zipfile)
+
+ with tqdm(total=len(gt_files), disable=not args.VERBOSE) as pbar:
+ pbar.set_description("Integrating results...")
+ if args.DEBUG or args.NUM_WORKERS <= 1:
+ for gt_file, det_file, file_idx in zip(gt_files, det_files, file_indices):
+ sample_res = eval_single(args, gt_file, det_file, file_idx)
+ accumulate_result(global_res, sample_res, args.E2E, args.DUMP_SAMPLE_RESULT)
+ pbar.update(1)
+ else:
+ futures = []
+ executor = ProcessPoolExecutor(max_workers=args.NUM_WORKERS)
+ for gt_file, det_file, file_idx in zip(gt_files, det_files, file_indices):
+ future = executor.submit(eval_single, args, gt_file, det_file, file_idx)
+ futures.append(future)
+
+ for future in as_completed(futures):
+ sample_res = future.result()
+ accumulate_result(global_res, sample_res, args.E2E, args.DUMP_SAMPLE_RESULT)
+ pbar.update(1)
+
+ executor.shutdown()
+
+ # Calculate global recall, precision, hmean after accumulate all sample-results.
+ calculate_global_rph(global_res, args.E2E)
+
+ res_dict = {"all": asdict(global_res.stats)}
+ dump_path = os.path.join(args.OUTPUT_PATH, "results.json")
+ dump_json(dump_path, res_dict)
+
+ if args.DUMP_SAMPLE_RESULT:
+ dump_path = os.path.join(args.OUTPUT_PATH, f"sample_wise.json")
+ dump_json(dump_path, asdict(global_res))
+
+ if args.VERBOSE:
+ pprint("Calculated!")
+ pprint(res_dict)
+
+ return res_dict
+
+
+def get_file_paths(gt_zipfile, submit_zipfile):
+ gt_zipfile_loaded = load_zip_file(gt_zipfile)
+ submission_zipfile_loaded = load_zip_file(submit_zipfile)
+ gt_files, det_files, file_indices = [], [], []
+
+ for file_idx in gt_zipfile_loaded:
+ gt_file = decode_utf8(gt_zipfile_loaded[file_idx])
+
+ if file_idx in submission_zipfile_loaded:
+ det_file = decode_utf8(submission_zipfile_loaded[file_idx])
+ if det_file is None:
+ det_file = ""
+ else:
+ det_file = ""
+
+ gt_files.append(gt_file)
+ det_files.append(det_file)
+ file_indices.append(file_idx)
+ return gt_files, det_files, file_indices
+
+
+def eval_single(args, gt_file, det_file, file_id):
+ gt_boxes = parse_single_file(gt_file, args.CRLF, True, False, box_type=args.BOX_TYPE)
+ det_boxes = parse_single_file(
+ det_file,
+ args.CRLF,
+ args.TRANSCRIPTION,
+ args.CONFIDENCES,
+ box_type=args.BOX_TYPE,
+ )
+ sample_res = evaluation(args, gt_boxes, det_boxes)
+ sample_res.img_id = file_id
+ return sample_res
+
+
+def parse_single_file(
+ content,
+ has_crlf=True,
+ with_transcription=False,
+ with_confidence=False,
+ img_width=0,
+ img_height=0,
+ sort_by_confidences=True,
+ box_type="QUAD",
+):
+ """Returns all points, confindences and transcriptions of a file in lists.
+
+ valid line formats:
+ xmin,ymin,xmax,ymax,[confidence],[transcription]
+ x1,y1,x2,y2,x3,y3,x4,y4,[confidence],[transcription]
+ """
+ result_boxes = []
+ lines = content.split("\r\n" if has_crlf else "\n")
+ for line in lines:
+ line = line.replace("\r", "").replace("\n", "")
+ if line != "":
+ result_box = parse_values_from_single_line(
+ line,
+ with_transcription,
+ with_confidence,
+ img_width,
+ img_height,
+ box_type=box_type,
+ )
+ result_boxes.append(result_box)
+
+ if with_confidence and len(result_boxes) and sort_by_confidences:
+ result_boxes.sort(key=lambda x: x.confidence, reverse=True)
+
+ return result_boxes
+
+
+def parse_values_from_single_line(
+ line,
+ with_transcription=False,
+ with_confidence=False,
+ img_width=0,
+ img_height=0,
+ box_type="QUAD",
+) -> Box:
+ """
+ Validate the format of the line.
+ If the line is not valid an ValueError will be raised.
+ If maxWidth and maxHeight are specified, all points must be inside the image bounds.
+ Posible values are:
+ LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription]
+ LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription]
+ LTRB="POLY": x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription]
+
+ box_type:
+ - LTRB: add description
+ - QUAD: add description
+ - POLY: add description
+
+ Returns values from a textline. Points , [Confidences], [Transcriptions]
+ """
+ confidence = 0.0
+ transcription = ""
+
+ if box_type == "LTRB":
+ box_type = QUAD
+ num_points = 4
+ m = ltrb_regex_match(line, with_transcription, with_confidence)
+ xmin = int(m.group(1))
+ ymin = int(m.group(2))
+ xmax = int(m.group(3))
+ ymax = int(m.group(4))
+
+ validate_min_max_bounds(lower_val=xmin, upper_val=xmax)
+ validate_min_max_bounds(lower_val=ymin, upper_val=ymax)
+
+ points = [float(m.group(i)) for i in range(1, (num_points + 1))]
+ points = convert_ltrb2quad(points)
+
+ if img_width > 0 and img_height > 0:
+ validate_point_inside_bounds(xmin, ymin, img_width, img_height)
+ validate_point_inside_bounds(xmax, ymax, img_width, img_height)
+
+ elif box_type == "QUAD":
+ box_type = QUAD
+
+ num_points = 8
+ m = quad_regex_match(line, with_transcription, with_confidence)
+ points = [float(m.group(i)) for i in range(1, (num_points + 1))]
+
+ # validate_clockwise_points(points)
+ if img_width > 0 and img_height > 0:
+ validate_point_inside_bounds(points[0], points[1], img_width, img_height)
+ validate_point_inside_bounds(points[2], points[3], img_width, img_height)
+ validate_point_inside_bounds(points[4], points[5], img_width, img_height)
+ validate_point_inside_bounds(points[6], points[7], img_width, img_height)
+
+ elif box_type == "POLY":
+ # TODO: TotalText GT보고 정하기
+ # TODO: 이렇게 리턴하는 건 굉장히 위험
+ splitted_line = line.split(",")
+ tmp_transcription = list()
+
+ if with_transcription:
+ tmp_transcription.append(splitted_line.pop())
+ while not len("".join(tmp_transcription)):
+ tmp_transcription.append(splitted_line.pop())
+
+ if with_confidence:
+ if len(splitted_line) % 2 != 0:
+ confidence = float(splitted_line.pop())
+ points = [float(x) for x in splitted_line]
+ else:
+ backward_idx = len(splitted_line) - 1
+ while backward_idx > 0:
+ if splitted_line[backward_idx].isdigit() and len(splitted_line) % 2 != 0:
+ break
+ tmp_transcription.append(splitted_line.pop())
+ backward_idx -= 1
+ confidence = float(splitted_line.pop())
+ points = [float(x) for x in splitted_line]
+ else:
+ if len(splitted_line) % 2 == 0:
+ points = [float(x) for x in splitted_line]
+ else:
+ backward_idx = len(splitted_line) - 1
+ while backward_idx > 0:
+ if splitted_line[backward_idx].isdigit():
+ break
+ tmp_transcription.append(splitted_line.pop())
+ backward_idx -= 1
+ points = [float(x) for x in splitted_line]
+
+ transcription = ",".join(tmp_transcription)
+ return POLY(points, confidence=confidence, transcription=transcription)
+ else:
+ raise RuntimeError(f"Something is wrong with configuration. Box Type: [{box_type}]")
+
+ # QUAD or LTRB format
+ if with_confidence:
+ try:
+ confidence = float(m.group(num_points + 1))
+ except ValueError:
+ raise ValueError("Confidence value must be a float")
+
+ if with_transcription:
+ pos_transcription = num_points + (2 if with_confidence else 1)
+ transcription = m.group(pos_transcription)
+ m2 = re.match(r"^\s*\"(.*)\"\s*$", transcription)
+
+ # Transcription with double quotes
+ # We extract the value and replace escaped characters
+ if m2 is not None:
+ transcription = m2.group(1).replace("\\\\", "\\").replace('\\"', '"')
+
+ result_box = box_type(points, confidence=confidence, transcription=transcription)
+ return result_box
+
+
+def parse_jylee_annot(quad, transcription, box_type):
+ assert box_type == "QUAD"
+ points = [
+ quad["x1"],
+ quad["y1"],
+ quad["x2"],
+ quad["y2"],
+ quad["x3"],
+ quad["y3"],
+ quad["x4"],
+ quad["y4"],
+ ]
+ result_box = QUAD(points, confidence=0.0, transcription=transcription)
+ return result_box
+
+
+def parse_clova_ocr(quad, transcription, box_type):
+ assert box_type == "QUAD"
+ result_box = QUAD(quad, confidence=0.0, transcription=transcription)
+ return result_box
+
+
+if __name__ == "__main__":
+ main()
diff --git a/cleval/torchmetric.py b/cleval/torchmetric.py
new file mode 100644
index 0000000..843f3e0
--- /dev/null
+++ b/cleval/torchmetric.py
@@ -0,0 +1,298 @@
+"""
+TODO: Support scalewise eval
+TODO: Support orientation accuracy
+"""
+
+import cv2
+import numpy as np
+import torch
+from torchmetrics import Metric
+
+from cleval.box_types import QUAD
+from cleval.data import SampleResult
+from cleval.eval_functions import evaluation
+
+
+class Options:
+ def __init__(
+ self,
+ case_sensitive,
+ recall_gran_penalty,
+ precision_gran_penalty,
+ vertical_aspect_ratio_thresh,
+ ap_constraint,
+ ):
+ self.DUMP_SAMPLE_RESULT = False
+ self.E2E = (True,) # change in runtime. See update function.
+ self.ORIENTATION = False
+ self.CASE_SENSITIVE = case_sensitive
+ self.RECALL_GRANULARITY_PENALTY_WEIGHT = recall_gran_penalty
+ self.PRECISION_GRANULARITY_PENALTY_WEIGHT = precision_gran_penalty
+ self.VERTICAL_ASPECT_RATIO_THRESH = vertical_aspect_ratio_thresh
+ self.AREA_PRECISION_CONSTRAINT = ap_constraint
+
+
+class CLEvalMetric(Metric):
+ full_state_update: bool = False
+
+ def __init__(
+ self,
+ dist_sync_on_step=False,
+ case_sensitive=True,
+ recall_gran_penalty=1.0,
+ precision_gran_penalty=1.0,
+ vertical_aspect_ratio_thresh=0.5,
+ ap_constraint=0.3,
+ scale_wise=False,
+ scale_bins=(0.0, 0.005, 0.01, 0.015, 0.02, 0.025, 0.1, 0.5, 1.0),
+ scale_range=(0.0, 1.0),
+ ):
+ super().__init__(dist_sync_on_step=dist_sync_on_step)
+ self.options = Options(
+ case_sensitive,
+ recall_gran_penalty,
+ precision_gran_penalty,
+ vertical_aspect_ratio_thresh,
+ ap_constraint,
+ )
+ self.scale_range = scale_range
+
+ self.scalewise_metric = {}
+ if scale_wise:
+ bin_ranges = [scale_bins[i : i + 2] for i in range(len(scale_bins) - 1)]
+ for bin_range in bin_ranges:
+ self.scalewise_metric[bin_range] = CLEvalMetric(
+ dist_sync_on_step=dist_sync_on_step,
+ case_sensitive=case_sensitive,
+ recall_gran_penalty=recall_gran_penalty,
+ precision_gran_penalty=precision_gran_penalty,
+ vertical_aspect_ratio_thresh=vertical_aspect_ratio_thresh,
+ ap_constraint=ap_constraint,
+ scale_wise=False,
+ scale_range=bin_range,
+ )
+
+ # Detection
+ self.add_state("det_num_char_gt", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+ self.add_state("det_num_char_det", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+ self.add_state(
+ "det_gran_score_recall",
+ torch.tensor(0, dtype=torch.float32),
+ dist_reduce_fx="sum",
+ )
+ self.add_state(
+ "det_num_char_tp_recall",
+ torch.tensor(0, dtype=torch.int32),
+ dist_reduce_fx="sum",
+ )
+ self.add_state(
+ "det_gran_score_precision",
+ torch.tensor(0, dtype=torch.float32),
+ dist_reduce_fx="sum",
+ )
+ self.add_state(
+ "det_num_char_tp_precision",
+ torch.tensor(0, dtype=torch.int32),
+ dist_reduce_fx="sum",
+ )
+
+ self.add_state("det_num_char_fp", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+
+ # E2E
+ self.add_state("e2e_num_char_gt", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+ self.add_state("e2e_num_char_det", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+ self.add_state(
+ "e2e_gran_score_recall",
+ torch.tensor(0, dtype=torch.float32),
+ dist_reduce_fx="sum",
+ )
+ self.add_state(
+ "e2e_num_char_tp_recall",
+ torch.tensor(0, dtype=torch.int32),
+ dist_reduce_fx="sum",
+ )
+ self.add_state(
+ "e2e_gran_score_precision",
+ torch.tensor(0, dtype=torch.float32),
+ dist_reduce_fx="sum",
+ )
+ self.add_state(
+ "e2e_num_char_tp_precision",
+ torch.tensor(0, dtype=torch.int32),
+ dist_reduce_fx="sum",
+ )
+
+ self.add_state("e2e_num_char_fp", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+
+ # split-merge cases
+ self.add_state("num_splitted", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+ self.add_state("num_merged", torch.tensor(0, dtype=torch.int32), dist_reduce_fx="sum")
+ self.add_state(
+ "num_char_overlapped",
+ torch.tensor(0, dtype=torch.int32),
+ dist_reduce_fx="sum",
+ )
+
+ def to(self, *args, **kwargs):
+ super().to(*args, **kwargs)
+ for key, metric in self.scalewise_metric.items():
+ self.scalewise_metric[key] = metric.to(*args, **kwargs)
+ return self
+
+ def update(
+ self,
+ det_quads,
+ gt_quads,
+ det_letters=None,
+ gt_letters=None,
+ gt_is_dcs=None,
+ img_longer_length=None,
+ ):
+ """
+ Args:
+ det_quads (NDArray[float32]): (N, 8) detected quads
+ gt_quads (NDArray[float32]): (N, 8) target quads
+ det_letters (List[str]): detected letters
+ gt_letters (List[str]): target letters
+ gt_is_dcs (List[bool]): is dc gt quad?
+ img_longer_length (int): longer length of images
+ """
+ gt_inps = self.__make_eval_input(gt_quads, gt_letters, gt_is_dcs, img_longer_length)
+ det_inps = self.__make_eval_input(det_quads, det_letters)
+ self.options.E2E = False if gt_letters is None and det_letters is None else True
+ sample_res = evaluation(self.options, gt_inps, det_inps, scale_range=self.scale_range)
+ self.__accumulate(sample_res)
+
+ for metric in self.scalewise_metric.values():
+ if img_longer_length is None:
+ raise ValueError("[img_longer_length] argument should be " "given for scalewise evaluation.")
+ metric(
+ det_quads,
+ gt_quads,
+ det_letters,
+ gt_letters,
+ gt_is_dcs,
+ img_longer_length,
+ )
+
+ def __make_eval_input(self, quads, letters, is_dcs=None, img_longer_length=None):
+ eval_inps = []
+ for i in range(len(quads)):
+ box_scale = None
+ if img_longer_length is not None:
+ box_scale = self.__check_box_scale(quads[i], img_longer_length)
+
+ eval_inp = QUAD(
+ quads[i],
+ confidence=0.0,
+ transcription=None if letters is None else letters[i],
+ is_dc=None if is_dcs is None else is_dcs[i],
+ scale=box_scale,
+ )
+ eval_inps.append(eval_inp)
+ return eval_inps
+
+ @staticmethod
+ def __check_box_scale(quad, img_longer_length):
+ """The method calculates box scale
+ Box scale is defined using the equation: char-height / image-longer size
+ The size of a box is defined w.r.t image size, allowing us to judge how sensitive
+ the model is to the box scale.
+ """
+ rect = cv2.minAreaRect(quad.reshape(4, 2))
+ quad = cv2.boxPoints(rect)
+ quad = np.around(quad)
+ box_w = np.linalg.norm(quad[1] - quad[0]) + np.linalg.norm(quad[3] - quad[2])
+ box_h = np.linalg.norm(quad[2] - quad[1]) + np.linalg.norm(quad[0] - quad[3])
+ box_scale = min(box_w, box_h) / 2 / img_longer_length
+ return box_scale
+
+ def __accumulate(self, sample_res: SampleResult):
+ self.num_splitted += sample_res.stats.num_splitted
+ self.num_merged += sample_res.stats.num_merged
+ self.num_char_overlapped += sample_res.stats.num_char_overlapped
+
+ self.det_num_char_gt += sample_res.stats.det.num_char_gt
+ self.det_num_char_det += sample_res.stats.det.num_char_det
+ self.det_gran_score_recall += sample_res.stats.det.gran_score_recall
+ self.det_num_char_tp_recall += sample_res.stats.det.num_char_tp_recall
+ self.det_gran_score_precision += sample_res.stats.det.gran_score_precision
+ self.det_num_char_tp_precision += sample_res.stats.det.num_char_tp_precision
+ self.det_num_char_fp += sample_res.stats.det.num_char_fp
+
+ self.e2e_num_char_gt += sample_res.stats.e2e.num_char_gt
+ self.e2e_num_char_det += sample_res.stats.e2e.num_char_det
+ self.e2e_gran_score_recall += sample_res.stats.e2e.gran_score_recall
+ self.e2e_num_char_tp_recall += sample_res.stats.e2e.num_char_tp_recall
+ self.e2e_gran_score_precision += sample_res.stats.e2e.gran_score_precision
+ self.e2e_num_char_tp_precision += sample_res.stats.e2e.num_char_tp_precision
+ self.e2e_num_char_fp += sample_res.stats.e2e.num_char_fp
+
+ def compute(self):
+ det_r, det_p, det_h = self.__calculate_rph(
+ self.det_num_char_gt,
+ self.det_num_char_det,
+ self.det_gran_score_recall,
+ self.det_num_char_tp_recall,
+ self.det_gran_score_precision,
+ self.det_num_char_tp_precision,
+ )
+ e2e_r, e2e_p, e2e_h = self.__calculate_rph(
+ self.e2e_num_char_gt,
+ self.e2e_num_char_det,
+ self.e2e_gran_score_recall,
+ self.e2e_num_char_tp_recall,
+ self.e2e_gran_score_precision,
+ self.e2e_num_char_tp_precision,
+ )
+ return_dict = {
+ "det_r": det_r,
+ "det_p": det_p,
+ "det_h": det_h,
+ "e2e_r": e2e_r,
+ "e2e_p": e2e_p,
+ "e2e_h": e2e_h,
+ "num_splitted": self.num_splitted,
+ "num_merged": self.num_merged,
+ "num_char_overlapped": self.num_char_overlapped,
+ "scale_wise": {},
+ }
+
+ for scale_bin, metric in self.scalewise_metric.items():
+ return_dict["scale_wise"][scale_bin] = metric.compute()
+
+ return return_dict
+
+ def reset(self):
+ super().reset()
+ for metric in self.scalewise_metric.values():
+ metric.reset()
+
+ def __calculate_rph(
+ self,
+ num_char_gt,
+ num_char_det,
+ gran_score_recall,
+ num_char_tp_recall,
+ gran_score_precision,
+ num_char_tp_precision,
+ ):
+ total_gt = num_char_gt
+ total_det = num_char_det
+ gran_gt = gran_score_recall
+ tp_gt = num_char_tp_recall
+ gran_det = gran_score_precision
+ tp_det = num_char_tp_precision
+
+ # Sample Score : Character correct length - Granularity Penalty
+ recall = 0.0 if total_gt == 0 else max(0.0, tp_gt - gran_gt) / total_gt
+ precision = 0.0 if total_det == 0 else max(0.0, tp_det - gran_det) / total_det
+ hmean = self.harmonic_mean(recall, precision)
+ return recall, precision, hmean
+
+ def harmonic_mean(self, score1, score2):
+ """get harmonic mean value"""
+ if score1 + score2 == 0:
+ return torch.tensor(0, dtype=torch.float32, device=self.device)
+ else:
+ return (2 * score1 * score2) / (score1 + score2)
diff --git a/cleval/utils.py b/cleval/utils.py
new file mode 100644
index 0000000..78876da
--- /dev/null
+++ b/cleval/utils.py
@@ -0,0 +1,203 @@
+import codecs
+import json
+import re
+import subprocess
+import zipfile
+
+from numba import njit
+
+
+def load_zip_file(file):
+ """
+ Returns an array with the contents (filtered by fileNameRegExp) of a ZIP file.
+ all_entries validates that all entries in the ZIP file pass the fileNameRegExp
+ """
+ archive = zipfile.ZipFile(file, mode="r", allowZip64=True)
+
+ pairs = dict()
+ for name in archive.namelist():
+ key_name = (
+ name.replace("gt_", "").replace("res_", "").replace(".txt", "").replace(".json", "").replace(".jpg", "")
+ )
+ pairs[key_name] = archive.read(name)
+ return pairs
+
+
+def decode_utf8(raw):
+ """
+ Returns a Unicode object
+ """
+ raw = codecs.decode(raw, "utf-8", "replace")
+
+ # extracts BOM if exists
+ raw = raw.encode("utf8")
+ if raw.startswith(codecs.BOM_UTF8):
+ raw = raw.replace(codecs.BOM_UTF8, b"", 1)
+ return raw.decode("utf-8")
+
+
+def dump_json(json_file_path, json_data):
+ with open(json_file_path, "w", encoding="utf-8") as f:
+ json.dump(json_data, f)
+
+
+def read_json(json_file_path):
+ with open(json_file_path, "r", encoding="utf-8") as f:
+ json_data = json.load(f)
+ return json_data
+
+
+def convert_ltrb2quad(points):
+ """Convert point format from LTRB to QUAD"""
+ new_points = [
+ points[0],
+ points[1],
+ points[2],
+ points[1],
+ points[2],
+ points[3],
+ points[0],
+ points[3],
+ ]
+ return new_points
+
+
+def ltrb_regex_match(line, with_transcription, with_confidence):
+ if with_transcription and with_confidence:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*"
+ r",\s*(-?[0-9]+)\s*"
+ r",\s*([0-9]+)\s*"
+ r",\s*([0-9]+)\s*"
+ r",\s*([0-1].?[0-9]*)\s*,(.*)$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. " "Should be: xmin,ymin,xmax,ymax,confidence,transcription")
+ elif with_confidence:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*," r"\s*(-?[0-9]+)\s*," r"\s*([0-9]+)\s*," r"\s*([0-9]+)\s*," r"\s*([0-1].?[0-9]*)\s*$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence")
+ elif with_transcription:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*," r"\s*(-?[0-9]+)\s*," r"\s*([0-9]+)\s*," r"\s*([0-9]+)\s*,(.*)$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. Should be: xmin,ymin,xmax,ymax,transcription")
+ else:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*," r"\s*(-?[0-9]+)\s*," r"\s*([0-9]+)\s*," r"\s*([0-9]+)\s*,?\s*$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. Should be: xmin,ymin,xmax,ymax")
+ return m
+
+
+def quad_regex_match(line, with_transcription, with_confidence):
+ if with_transcription and with_confidence:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*([0-1].?[0-9]*)\s*,(.*)$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. " "Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence,transcription")
+ elif with_confidence:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*([0-1].?[0-9]*)\s*$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence")
+ elif with_transcription:
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,(.*)$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,transcription")
+ else:
+ if line[-1] == ",":
+ line = line[:-1]
+ m = re.match(
+ r"^\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*,"
+ r"\s*(-?[0-9]+)\s*$",
+ line,
+ )
+ if m is None:
+ raise ValueError("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4")
+ return m
+
+
+@njit
+def lcs(s1, s2):
+ """Longeset Common Sequence between s1 & s2"""
+ # https://stackoverflow.com/questions/48651891/longest-common-subsequence-in-python
+ if len(s1) == 0 or len(s2) == 0:
+ return 0, ""
+ matrix = [["" for _ in range(len(s2))] for _ in range(len(s1))]
+ for i in range(len(s1)):
+ for j in range(len(s2)):
+ if s1[i] == s2[j]:
+ if i == 0 or j == 0:
+ matrix[i][j] = s1[i]
+ else:
+ matrix[i][j] = matrix[i - 1][j - 1] + s1[i]
+ else:
+ if len(matrix[i - 1][j]) > len(matrix[i][j - 1]):
+ matrix[i][j] = matrix[i - 1][j]
+ else:
+ matrix[i][j] = matrix[i][j - 1]
+ cs = matrix[-1][-1]
+ return len(cs), cs
+
+
+@njit
+def harmonic_mean(score1, score2):
+ """get harmonic mean value"""
+ if score1 + score2 == 0:
+ return 0
+ else:
+ return (2 * score1 * score2) / (score1 + score2)
+
+
+def cpu_count():
+ """Get number of cpu
+ os.cpu_count() has a problem with docker container.
+ For example, we have 72 cpus. os.cpu_count() always return 72
+ even if we allocate only 4 cpus for container.
+ """
+ return int(subprocess.check_output("nproc").decode().strip())
diff --git a/cleval/validation.py b/cleval/validation.py
new file mode 100644
index 0000000..e23c9bb
--- /dev/null
+++ b/cleval/validation.py
@@ -0,0 +1,69 @@
+from cleval.utils import decode_utf8, load_zip_file
+
+
+def validate_data(gt_file, submit_file, has_crlf):
+ gt = load_zip_file(gt_file)
+ subm = load_zip_file(submit_file)
+
+ # Validate format of GroundTruth
+ for k in gt:
+ validate_lines_in_file(k, gt[k], has_crlf)
+
+ # Validate format of results
+ for k in subm:
+ if k not in gt:
+ raise ValueError("The sample %s not present in GT" % k)
+ validate_lines_in_file(k, subm[k], has_crlf)
+
+
+def validate_lines_in_file(file_name, file_contents, has_crlf=True):
+ """This function validates that all lines of the file.
+ Execute line validation function for each line.
+ """
+ utf8file = decode_utf8(file_contents)
+ if utf8file is None:
+ raise ValueError("The file %s is not UTF-8" % file_name)
+
+ lines = utf8file.split("\r\n" if has_crlf else "\n")
+ for line in lines:
+ _ = line.replace("\r", "").replace("\n", "")
+
+
+def validate_point_inside_bounds(x, y, img_width, img_height):
+ if x < 0 or x > img_width:
+ raise ValueError("X value (%s) not valid. Image dimensions: (%s,%s)" % (x, img_width, img_height))
+ if y < 0 or y > img_height:
+ raise ValueError("Y value (%s) not valid. Image dimensions: (%s,%s)" % (y, img_width, img_height))
+
+
+def validate_min_max_bounds(lower_val, upper_val):
+ if lower_val > upper_val:
+ raise ValueError(f"Value {lower_val} should be smaller than value {upper_val}.")
+
+
+def validate_clockwise_points(points):
+ """
+ Validates that the points are in clockwise order.
+ """
+
+ if len(points) != 8:
+ raise ValueError("Points list not valid." + str(len(points)))
+
+ point = [
+ [int(points[0]), int(points[1])],
+ [int(points[2]), int(points[3])],
+ [int(points[4]), int(points[5])],
+ [int(points[6]), int(points[7])],
+ ]
+ edge = [
+ (point[1][0] - point[0][0]) * (point[1][1] + point[0][1]),
+ (point[2][0] - point[1][0]) * (point[2][1] + point[1][1]),
+ (point[3][0] - point[2][0]) * (point[3][1] + point[2][1]),
+ (point[0][0] - point[3][0]) * (point[0][1] + point[3][1]),
+ ]
+
+ summatory = edge[0] + edge[1] + edge[2] + edge[3]
+ if summatory > 0:
+ raise ValueError(
+ "Points are not clockwise. " "The coordinates of bounding quads have to be given in clockwise order."
+ )
diff --git a/config/config.py b/config/config.py
deleted file mode 100755
index e541c11..0000000
--- a/config/config.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import json
-# Name of the script used for the evalution
-evaluation_script = 'script'
-
-# Upload instructions
-instructions = """The submitted zip file is automatically checked at the time of submission, and a submission log is presented to the user along with a confirmation of the submission. The checks performed are the following:
- -See here an example of the expected submission file
-""" -# Extension of the GT file. gt.[extension] -gt_ext = "zip" -# Acronym for the task. It's used to cache the Images -acronym = "IST-T1" -# Title of the Task -title = "CLEval Web Visualization" -# Custom JavaScript for the visualiztion. -customJS = 'visualization_TL_iou.js' -# Custom CSS for the visualiztion. -customCSS = 'visualization_TL_iou.css' -# Parameters used to show the results of a method and the method's ranking -method_params = json.loads( - """{ - "Detection":{ - "recall": {"long_name":"Recall","type":"double","order":"","grafic":"1","format":"perc"}, - "precision":{"long_name":"Precision","type":"double","order":"","grafic":"1","format":"perc"}, - "hmean":{"long_name":"Hmean","type":"double","order":"desc","grafic":"1","format":"perc"}}, - "EndtoEnd":{ - "recall": {"long_name":"Recall","type":"double","order":"","grafic":"1","format":"perc"}, - "precision":{"long_name":"Precision","type":"double","order":"","grafic":"1","format":"perc"}, - "hmean":{"long_name":"Hmean","type":"double","order":"desc","grafic":"1","format":"perc"}, - "recognition_score":{"long_name":"RS","type":"double","order":"","grafic":"1","format":""}}, - "Detection_Metadata":{ - "num_merge":{"long_name":"Num merge","type":"int","order":"","grafic":"1","format":""}, - "num_split":{"long_name":"Num split","type":"int","order":"","grafic":"1","format":""}, - "num_false_pos":{"long_name":"Num FP","type":"int","order":"","grafic":"1","format":""}, - "char_miss":{"long_name":"Char miss","type":"int","order":"","grafic":"1","format":""}, - "char_overlap":{"long_name":"Char overlap","type":"int","order":"","grafic":"1","format":""}, - "char_false_pos":{"long_name":"Char FP","type":"int","order":"","grafic":"1","format":""}}, - "EndtoEnd_Metadata":{ - "num_merge":{"long_name":"Num merge","type":"int","order":"","grafic":"1","format":""}, - "num_split":{"long_name":"Num split","type":"int","order":"","grafic":"1","format":""}, - "num_false_pos":{"long_name":"Num FP","type":"int","order":"","grafic":"1","format":""}, - "char_miss":{"long_name":"Char miss","type":"int","order":"","grafic":"1","format":""}, - "char_false_pos":{"long_name":"Char FP","type":"int","order":"","grafic":"1","format":""}} - }""") -# Parameters to show for each sample -sample_params = json.loads("""{ - "Detection":{ - "recall":{"long_name":"DET Recall","type":"double","order":"","grafic":"","format":"perc"}, - "precision":{"long_name":"DET Precision","type":"double","order":"","grafic":"","format":"perc"}, - "hmean":{"long_name":"DET Hmean","type":"double","order":"desc","grafic":"","format":"perc"}}, - "EndtoEnd":{ - "recall":{"long_name":"E2E Recall","type":"double","order":"","grafic":"","format":"perc"}, - "precision":{"long_name":"E2E Precision","type":"double","order":"","grafic":"","format":"perc"}, - "hmean":{"long_name":"E2E Hmean","type":"double","order":"desc","grafic":"","format":"perc"}} - }""") -# Parameters to ask for for each submition -submit_params = json.loads("""{}""") -# Regular expression to get the Sample ID from the image name. ID must be the first capturing group. -image_name_to_id_str = '*([0-9]+)*.(jpg|gif|png)' \ No newline at end of file diff --git a/file_utils.py b/file_utils.py deleted file mode 100644 index c6f52ee..0000000 --- a/file_utils.py +++ /dev/null @@ -1,67 +0,0 @@ -import re -import codecs -import zipfile - - -def load_zip_file_keys(file, file_name_reg_exp=''): - try: - archive = zipfile.ZipFile(file, mode='r', allowZip64=True) - except: - raise Exception('Error loading the ZIP archive.') - - pairs = [] - - for name in archive.namelist(): - addFile = True - keyName = name - if file_name_reg_exp != "": - m = re.match(file_name_reg_exp, name) - if m == None: - addFile = False - else: - if len(m.groups()) > 0: - keyName = m.group(1) - - if addFile: - pairs.append(keyName) - - return pairs - - -def load_zip_file(file, file_name_reg_exp='', allEntries=False): - """ - Returns an array with the contents (filtered by fileNameRegExp) of a ZIP file. - The key's are the names or the file or the capturing group definied in the fileNameRegExp - allEntries validates that all entries in the ZIP file pass the fileNameRegExp - """ - try: - archive = zipfile.ZipFile(file, mode='r', allowZip64=True) - except: - raise Exception('Error loading the ZIP archive') - - pairs = dict() - for name in archive.namelist(): - addFile = True - keyName = name.replace('gt_', '').replace('res_', '').replace('.txt', '') - - if addFile: - pairs[keyName] = archive.read(name) - else: - if allEntries: - raise Exception('ZIP entry not valid: %s' % name) - return pairs - - -def decode_utf8(raw): - """ - Returns a Unicode object on success, or None on failure - """ - try: - raw = codecs.decode(raw, 'utf-8', 'replace') - # extracts BOM if exists - raw = raw.encode('utf8') - if raw.startswith(codecs.BOM_UTF8): - raw = raw.replace(codecs.BOM_UTF8, '', 1) - return raw.decode('utf-8') - except Exception: - return None diff --git a/gt/gt.zip b/gt/gt.zip deleted file mode 100644 index 89c6284..0000000 Binary files a/gt/gt.zip and /dev/null differ diff --git a/images/ui-icons_444444_256x240.png b/images/ui-icons_444444_256x240.png deleted file mode 100755 index 19f664d..0000000 Binary files a/images/ui-icons_444444_256x240.png and /dev/null differ diff --git a/images/ui-icons_555555_256x240.png b/images/ui-icons_555555_256x240.png deleted file mode 100755 index e965f6d..0000000 Binary files a/images/ui-icons_555555_256x240.png and /dev/null differ diff --git a/images/ui-icons_777620_256x240.png b/images/ui-icons_777620_256x240.png deleted file mode 100755 index 9785948..0000000 Binary files a/images/ui-icons_777620_256x240.png and /dev/null differ diff --git a/images/ui-icons_777777_256x240.png b/images/ui-icons_777777_256x240.png deleted file mode 100755 index 323c456..0000000 Binary files a/images/ui-icons_777777_256x240.png and /dev/null differ diff --git a/images/ui-icons_cc0000_256x240.png b/images/ui-icons_cc0000_256x240.png deleted file mode 100755 index 45ac778..0000000 Binary files a/images/ui-icons_cc0000_256x240.png and /dev/null differ diff --git a/images/ui-icons_ffffff_256x240.png b/images/ui-icons_ffffff_256x240.png deleted file mode 100755 index fe41d2d..0000000 Binary files a/images/ui-icons_ffffff_256x240.png and /dev/null differ diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..356ff1e --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,10 @@ +[tool.isort] +profile = "black" + +[tool.black] +line-length = 120 +target-version = ['py38'] +include = '\.pyi?$' + +[tool.pytest.ini_options] +addopts = "-s" diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index b2cfa53..0000000 --- a/requirements.txt +++ /dev/null @@ -1,9 +0,0 @@ -bottle==0.12.17 -numpy==1.17.0 -Pillow==6.1.0 -Polygon3==3.0.8 -Shapely==1.6.4.post2 -six==1.12.0 -termcolor==1.1.0 -opencv-python==3.4.2.17 -tqdm==4.40.0 diff --git a/gt/gt_IC13.zip b/resources/gt/gt_IC13.zip similarity index 100% rename from gt/gt_IC13.zip rename to resources/gt/gt_IC13.zip diff --git a/gt/gt_IC15.zip b/resources/gt/gt_IC15.zip similarity index 100% rename from gt/gt_IC15.zip rename to resources/gt/gt_IC15.zip diff --git a/gt/gt_TotalText.zip b/resources/gt/gt_TotalText.zip similarity index 100% rename from gt/gt_TotalText.zip rename to resources/gt/gt_TotalText.zip diff --git a/screenshots/explanation.gif b/resources/screenshots/explanation.gif similarity index 100% rename from screenshots/explanation.gif rename to resources/screenshots/explanation.gif diff --git a/screenshots/pic1.jpg b/resources/screenshots/pic1.jpg similarity index 100% rename from screenshots/pic1.jpg rename to resources/screenshots/pic1.jpg diff --git a/screenshots/pic2.jpg b/resources/screenshots/pic2.jpg similarity index 100% rename from screenshots/pic2.jpg rename to resources/screenshots/pic2.jpg diff --git a/resources/test_data/gt/gt_eval_doc_v1_kr.zip b/resources/test_data/gt/gt_eval_doc_v1_kr.zip new file mode 100644 index 0000000..ae4193b Binary files /dev/null and b/resources/test_data/gt/gt_eval_doc_v1_kr.zip differ diff --git a/resources/test_data/gt/gt_eval_doc_v1_kr_single.zip b/resources/test_data/gt/gt_eval_doc_v1_kr_single.zip new file mode 100644 index 0000000..6f6e28c Binary files /dev/null and b/resources/test_data/gt/gt_eval_doc_v1_kr_single.zip differ diff --git a/resources/test_data/pred/res_eval_doc_v1_kr.zip b/resources/test_data/pred/res_eval_doc_v1_kr.zip new file mode 100644 index 0000000..37f5714 Binary files /dev/null and b/resources/test_data/pred/res_eval_doc_v1_kr.zip differ diff --git a/resources/test_data/pred/res_eval_doc_v1_kr_single.zip b/resources/test_data/pred/res_eval_doc_v1_kr_single.zip new file mode 100644 index 0000000..b39f080 Binary files /dev/null and b/resources/test_data/pred/res_eval_doc_v1_kr_single.zip differ diff --git a/rrc_evaluation_funcs.py b/rrc_evaluation_funcs.py deleted file mode 100644 index 9338f7b..0000000 --- a/rrc_evaluation_funcs.py +++ /dev/null @@ -1,300 +0,0 @@ -import json -import pprint -import sys;sys.path.append('./') -import zipfile -import re -import sys -import os -from io import StringIO - -from validation import * -from file_utils import decode_utf8 -from box_types import Box, QUAD, POLY - -from arg_parser import PARAMS - - -def print_help(): - sys.stdout.write('Usage: python %s.py -g=| t |
| ",s.document[0]).attr("colspan",t(this).attr("colspan")||1).appendTo(i)})},_contactContainers:function(e){var i,s,n,o,a,r,l,h,c,u,d=null,p=null;for(i=this.containers.length-1;i>=0;i--)if(!t.contains(this.currentItem[0],this.containers[i].element[0]))if(this._intersectsWith(this.containers[i].containerCache)){if(d&&t.contains(this.containers[i].element[0],d.element[0]))continue;d=this.containers[i],p=i}else this.containers[i].containerCache.over&&(this.containers[i]._trigger("out",e,this._uiHash(this)),this.containers[i].containerCache.over=0);if(d)if(1===this.containers.length)this.containers[p].containerCache.over||(this.containers[p]._trigger("over",e,this._uiHash(this)),this.containers[p].containerCache.over=1);else{for(n=1e4,o=null,c=d.floating||this._isFloating(this.currentItem),a=c?"left":"top",r=c?"width":"height",u=c?"pageX":"pageY",s=this.items.length-1;s>=0;s--)t.contains(this.containers[p].element[0],this.items[s].item[0])&&this.items[s].item[0]!==this.currentItem[0]&&(l=this.items[s].item.offset()[a],h=!1,e[u]-l>this.items[s][r]/2&&(h=!0),n>Math.abs(e[u]-l)&&(n=Math.abs(e[u]-l),o=this.items[s],this.direction=h?"up":"down"));if(!o&&!this.options.dropOnEmpty)return;if(this.currentContainer===this.containers[p])return this.currentContainer.containerCache.over||(this.containers[p]._trigger("over",e,this._uiHash()),this.currentContainer.containerCache.over=1),void 0;o?this._rearrange(e,o,null,!0):this._rearrange(e,null,this.containers[p].element,!0),this._trigger("change",e,this._uiHash()),this.containers[p]._trigger("change",e,this._uiHash(this)),this.currentContainer=this.containers[p],this.options.placeholder.update(this.currentContainer,this.placeholder),this.containers[p]._trigger("over",e,this._uiHash(this)),this.containers[p].containerCache.over=1}},_createHelper:function(e){var i=this.options,s=t.isFunction(i.helper)?t(i.helper.apply(this.element[0],[e,this.currentItem])):"clone"===i.helper?this.currentItem.clone():this.currentItem;return s.parents("body").length||t("parent"!==i.appendTo?i.appendTo:this.currentItem[0].parentNode)[0].appendChild(s[0]),s[0]===this.currentItem[0]&&(this._storedCSS={width:this.currentItem[0].style.width,height:this.currentItem[0].style.height,position:this.currentItem.css("position"),top:this.currentItem.css("top"),left:this.currentItem.css("left")}),(!s[0].style.width||i.forceHelperSize)&&s.width(this.currentItem.width()),(!s[0].style.height||i.forceHelperSize)&&s.height(this.currentItem.height()),s},_adjustOffsetFromHelper:function(e){"string"==typeof e&&(e=e.split(" ")),t.isArray(e)&&(e={left:+e[0],top:+e[1]||0}),"left"in e&&(this.offset.click.left=e.left+this.margins.left),"right"in e&&(this.offset.click.left=this.helperProportions.width-e.right+this.margins.left),"top"in e&&(this.offset.click.top=e.top+this.margins.top),"bottom"in e&&(this.offset.click.top=this.helperProportions.height-e.bottom+this.margins.top)},_getParentOffset:function(){this.offsetParent=this.helper.offsetParent();var e=this.offsetParent.offset();return"absolute"===this.cssPosition&&this.scrollParent[0]!==this.document[0]&&t.contains(this.scrollParent[0],this.offsetParent[0])&&(e.left+=this.scrollParent.scrollLeft(),e.top+=this.scrollParent.scrollTop()),(this.offsetParent[0]===this.document[0].body||this.offsetParent[0].tagName&&"html"===this.offsetParent[0].tagName.toLowerCase()&&t.ui.ie)&&(e={top:0,left:0}),{top:e.top+(parseInt(this.offsetParent.css("borderTopWidth"),10)||0),left:e.left+(parseInt(this.offsetParent.css("borderLeftWidth"),10)||0)}},_getRelativeOffset:function(){if("relative"===this.cssPosition){var t=this.currentItem.position();return{top:t.top-(parseInt(this.helper.css("top"),10)||0)+this.scrollParent.scrollTop(),left:t.left-(parseInt(this.helper.css("left"),10)||0)+this.scrollParent.scrollLeft()}}return{top:0,left:0}},_cacheMargins:function(){this.margins={left:parseInt(this.currentItem.css("marginLeft"),10)||0,top:parseInt(this.currentItem.css("marginTop"),10)||0}},_cacheHelperProportions:function(){this.helperProportions={width:this.helper.outerWidth(),height:this.helper.outerHeight()}},_setContainment:function(){var e,i,s,n=this.options;"parent"===n.containment&&(n.containment=this.helper[0].parentNode),("document"===n.containment||"window"===n.containment)&&(this.containment=[0-this.offset.relative.left-this.offset.parent.left,0-this.offset.relative.top-this.offset.parent.top,"document"===n.containment?this.document.width():this.window.width()-this.helperProportions.width-this.margins.left,("document"===n.containment?this.document.height()||document.body.parentNode.scrollHeight:this.window.height()||this.document[0].body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top]),/^(document|window|parent)$/.test(n.containment)||(e=t(n.containment)[0],i=t(n.containment).offset(),s="hidden"!==t(e).css("overflow"),this.containment=[i.left+(parseInt(t(e).css("borderLeftWidth"),10)||0)+(parseInt(t(e).css("paddingLeft"),10)||0)-this.margins.left,i.top+(parseInt(t(e).css("borderTopWidth"),10)||0)+(parseInt(t(e).css("paddingTop"),10)||0)-this.margins.top,i.left+(s?Math.max(e.scrollWidth,e.offsetWidth):e.offsetWidth)-(parseInt(t(e).css("borderLeftWidth"),10)||0)-(parseInt(t(e).css("paddingRight"),10)||0)-this.helperProportions.width-this.margins.left,i.top+(s?Math.max(e.scrollHeight,e.offsetHeight):e.offsetHeight)-(parseInt(t(e).css("borderTopWidth"),10)||0)-(parseInt(t(e).css("paddingBottom"),10)||0)-this.helperProportions.height-this.margins.top])},_convertPositionTo:function(e,i){i||(i=this.position);var s="absolute"===e?1:-1,n="absolute"!==this.cssPosition||this.scrollParent[0]!==this.document[0]&&t.contains(this.scrollParent[0],this.offsetParent[0])?this.scrollParent:this.offsetParent,o=/(html|body)/i.test(n[0].tagName);return{top:i.top+this.offset.relative.top*s+this.offset.parent.top*s-("fixed"===this.cssPosition?-this.scrollParent.scrollTop():o?0:n.scrollTop())*s,left:i.left+this.offset.relative.left*s+this.offset.parent.left*s-("fixed"===this.cssPosition?-this.scrollParent.scrollLeft():o?0:n.scrollLeft())*s}},_generatePosition:function(e){var i,s,n=this.options,o=e.pageX,a=e.pageY,r="absolute"!==this.cssPosition||this.scrollParent[0]!==this.document[0]&&t.contains(this.scrollParent[0],this.offsetParent[0])?this.scrollParent:this.offsetParent,l=/(html|body)/i.test(r[0].tagName);return"relative"!==this.cssPosition||this.scrollParent[0]!==this.document[0]&&this.scrollParent[0]!==this.offsetParent[0]||(this.offset.relative=this._getRelativeOffset()),this.originalPosition&&(this.containment&&(e.pageX-this.offset.click.left |