refactor: improve text line sorting algorithm with row grouping and center alignment

- Refactored `sort_text_lines` to use a more robust method for sorting text lines
  in reading order (top-to-bottom, left-to-right).
- Introduced helper functions to:
  - Compute vertical center of lines (`_center_y`)
  - Group lines into rows based on vertical median tolerance
  - Sort text within rows horizontally and flatten result
- Added `_calculate_row_tolerance` with dynamic tolerance factor based on median line height
- Defined `DEFAULT_ROW_TOLERANCE_FACTOR` constant for configurable grouping sensitivity
- Improved overall code style, spacing, and docstrings for clarity and maintainability

Author: schen1102

marker/util.py

@@ -10,25 +10,28 @@
 
 from marker.schema.polygon import PolygonBox
 from marker.settings import settings
+from statistics import median
 
+DEFAULT_ROW_TOLERANCE_FACTOR = 0.5
 OPENING_TAG_REGEX = re.compile(r"<((?:math|i|b))(?:\s+[^>]*)?>")
 CLOSING_TAG_REGEX = re.compile(r"</((?:math|i|b))>")
 TAG_MAPPING = {
-    'i': 'italic',
-    'b': 'bold',
-    'math': 'math',
-    'mark': 'highlight',
-    'sub': 'subscript',
-    'sup': 'superscript',
-    'small': 'small',
-    'u': 'underline',
-    'code': 'code'
+    "i": "italic",
+    "b": "bold",
+    "math": "math",
+    "mark": "highlight",
+    "sub": "subscript",
+    "sup": "superscript",
+    "small": "small",
+    "u": "underline",
+    "code": "code",
 }
 
+
 def strings_to_classes(items: List[str]) -> List[type]:
     classes = []
     for item in items:
-        module_name, class_name = item.rsplit('.', 1)
+        module_name, class_name = item.rsplit(".", 1)
         module = import_module(module_name)
         classes.append(getattr(module, class_name))
     return classes
@@ -52,7 +55,9 @@ def verify_config_keys(obj):
             if value is None:
                 none_vals += f"{attr_name}, "
 
-    assert len(none_vals) == 0, f"In order to use {obj.__class__.__name__}, you must set the configuration values `{none_vals}`."
+    assert len(none_vals) == 0, (
+        f"In order to use {obj.__class__.__name__}, you must set the configuration values `{none_vals}`."
+    )
 
 
 def assign_config(cls, config: BaseModel | dict | None):
@@ -122,7 +127,7 @@ def matrix_distance(boxes1: List[List[float]], boxes2: List[List[float]]) -> np.
     boxes1 = np.array(boxes1)  # Shape: (N, 4)
     boxes2 = np.array(boxes2)  # Shape: (M, 4)
 
-    boxes1_centers = (boxes1[:, :2] + boxes1[:, 2:]) / 2 # Shape: (M, 2)
+    boxes1_centers = (boxes1[:, :2] + boxes1[:, 2:]) / 2  # Shape: (M, 2)
     boxes2_centers = (boxes2[:, :2] + boxes2[:, 2:]) / 2  # Shape: (M, 2)
 
     boxes1_centers = boxes1_centers[:, np.newaxis, :]  # Shape: (N, 1, 2)
@@ -132,67 +137,128 @@ def matrix_distance(boxes1: List[List[float]], boxes2: List[List[float]]) -> np.
     return distances
 
 
-def sort_text_lines(lines: List[PolygonBox], tolerance=1.25):
-    # Sorts in reading order.  Not 100% accurate, this should only
-    # be used as a starting point for more advanced sorting.
-    vertical_groups = {}
-    for line in lines:
-        group_key = round(line.bbox[1] / tolerance) * tolerance
-        if group_key not in vertical_groups:
-            vertical_groups[group_key] = []
-        vertical_groups[group_key].append(line)
+def sort_text_lines(lines: List[PolygonBox]) -> List[PolygonBox]:
+    """
+    Sort text lines in reading order (top-to-bottom, left-to-right).
+
+    Groups lines into rows based on vertical proximity, then sorts each row horizontally.
+
+    Args:
+        lines: List of PolygonBox objects representing text lines
+
+    Returns:
+        List of PolygonBox objects sorted in reading order
+    """
+    if not lines:
+        return []
+
+    # Calculate row grouping tolerance based on median line height
+    row_tolerance = _calculate_row_tolerance(lines)
+
+    # Group lines into rows based on vertical position
+    rows = _group_lines_into_rows(lines, row_tolerance)
+
+    # Sort each row horizontally and flatten
+    return _sort_and_flatten_rows(rows)
+
+
+def _calculate_row_tolerance(lines: List[PolygonBox]) -> float:
+    """Calculate vertical tolerance for grouping lines into rows."""
+    line_heights = [line.height for line in lines]
+    return median(line_heights) * DEFAULT_ROW_TOLERANCE_FACTOR
+
+
+def _center_y(line: PolygonBox) -> float:
+    """Calculate the vertical center of a line."""
+    return (line.bbox[1] + line.bbox[3]) / 2 if line.bbox else 0.0
+
+
+def _group_lines_into_rows(lines: List[PolygonBox], tolerance: float) -> List[List[PolygonBox]]:
+    """Group lines into rows based on vertical proximity."""
+    # Sort lines by vertical position
+    sorted_lines = sorted(lines, key=lambda line: _center_y(line))
+
+    if not sorted_lines:
+        return []
 
-    # Sort each group horizontally and flatten the groups into a single list
-    sorted_lines = []
-    for _, group in sorted(vertical_groups.items()):
-        sorted_group = sorted(group, key=lambda x: x.bbox[0])
-        sorted_lines.extend(sorted_group)
+    rows: List[List[PolygonBox]] = []
+    current_row: List[PolygonBox] = [sorted_lines[0]]
+    current_row_y: float = _center_y(sorted_lines[0])
+
+    for line in sorted_lines[1:]:
+        if abs(_center_y(line) - current_row_y) <= tolerance:
+            # Line belongs to current row
+            current_row.append(line)
+        else:
+            # Start new row
+            rows.append(current_row)
+            current_row = [line]
+            current_row_y = _center_y(line)
+
+    # The last row
+    if current_row:
+        rows.append(current_row)
+
+    return rows
+
+
+def _sort_and_flatten_rows(rows: List[List[PolygonBox]]) -> List[PolygonBox]:
+    """Sort each row horizontally and flatten into a single list."""
+    sorted_lines: List[PolygonBox] = []
+
+    for row in rows:
+        # Sort row by horizontal position (left to right)
+        sorted_row: List[PolygonBox] = sorted(row, key=lambda line: line.bbox[0])
+        sorted_lines.extend(sorted_row)
 
     return sorted_lines
 
+
 def download_font():
     if not os.path.exists(settings.FONT_PATH):
         os.makedirs(os.path.dirname(settings.FONT_PATH), exist_ok=True)
         font_dl_path = f"{settings.ARTIFACT_URL}/{settings.FONT_NAME}"
-        with requests.get(font_dl_path, stream=True) as r, open(settings.FONT_PATH, 'wb') as f:
+        with requests.get(font_dl_path, stream=True) as r, open(settings.FONT_PATH, "wb") as f:
             r.raise_for_status()
             for chunk in r.iter_content(chunk_size=8192):
                 f.write(chunk)
 
+
 def get_opening_tag_type(tag):
     """
     Determines if a tag is an opening tag and extracts the tag type.
-    
+
     Args:
         tag (str): The tag string to analyze.
 
     Returns:
         tuple: (is_opening_tag (bool), tag_type (str or None))
     """
     match = OPENING_TAG_REGEX.match(tag)
-    
+
     if match:
         tag_type = match.group(1)
         if tag_type in TAG_MAPPING:
             return True, TAG_MAPPING[tag_type]
-    
+
     return False, None
 
+
 def get_closing_tag_type(tag):
     """
     Determines if a tag is an opening tag and extracts the tag type.
-    
+
     Args:
         tag (str): The tag string to analyze.
 
     Returns:
         tuple: (is_opening_tag (bool), tag_type (str or None))
     """
     match = CLOSING_TAG_REGEX.match(tag)
-    
+
     if match:
         tag_type = match.group(1)
         if tag_type in TAG_MAPPING:
             return True, TAG_MAPPING[tag_type]
-    
-    return False, None
+
+    return False, None