[REF]: get_table_areas

camelot/core.py

@@ -258,60 +258,118 @@ def get_relevant(self):
  )
 
  def get_table_areas(self, textlines, relevant_textedges):
- """Return a dict of interesting table areas on the PDF page.
+ """
+ Return a dict of interesting table areas on the PDF page.
 
  The table areas are calculated using relevant text edges.
- """
 
- def pad(area, average_row_height):
- x0 = area[0] - TABLE_AREA_PADDING
- y0 = area[1] - TABLE_AREA_PADDING
- x1 = area[2] + TABLE_AREA_PADDING
- # add a constant since table headers can be relatively up
- y1 = area[3] + average_row_height * 5
- return (x0, y0, x1, y1)
+ Parameters
+ ----------
+ textlines : list
+ List of text line objects that are relevant for determining table areas.
+ relevant_textedges : list
+ List of relevant text edge objects used to identify table areas.
+
+ Returns
+ -------
+ dict
+ A dictionary with padded table areas as keys and None as values.
+ """
 
- # sort relevant textedges in reading order
+ # Sort relevant text edges in reading order
  relevant_textedges.sort(key=lambda te: (-te.y0, te.coord))
 
+ table_areas = self._initialize_table_areas(relevant_textedges)
+ self._extend_table_areas_with_textlines(table_areas, textlines)
+
+ # Add padding to table areas
+ average_textline_height = self._calculate_average_textline_height(textlines)
+ padded_table_areas = {
+ self._pad(area, average_textline_height): None for area in table_areas
+ }
+
+ return padded_table_areas
+
+ def _initialize_table_areas(self, relevant_textedges):
+ """
+ Initialize table areas based on relevant text edges.
+
+ Parameters
+ ----------
+ relevant_textedges : list
+ List of relevant text edge objects used to initialize table areas.
+
+ Returns
+ -------
+ dict
+ A dictionary of table areas initialized from relevant text edges.
+ """
  table_areas = {}
  for te in relevant_textedges:
  if not table_areas:
  table_areas[(te.coord, te.y0, te.coord, te.y1)] = None
  else:
- found = None
- for area in table_areas:
- # check for overlap
- if te.y1 >= area[1] and te.y0 <= area[3]:
- found = area
- break
- if found is None:
- table_areas[(te.coord, te.y0, te.coord, te.y1)] = None
- else:
- table_areas.pop(found)
- updated_area = (
- found[0],
- min(te.y0, found[1]),
- max(found[2], te.coord),
- max(found[3], te.y1),
- )
- table_areas[updated_area] = None
-
- # extend table areas based on textlines that overlap
- # vertically. it's possible that these textlines were
- # eliminated during textedges generation since numbers and
- # chars/words/sentences are often aligned differently.
- # drawback: table areas that have paragraphs on their sides
- # will include the paragraphs too.
- sum_textline_height = 0
+ self._update_table_areas(table_areas, te)
+
+ return table_areas
+
+ def _update_table_areas(self, table_areas, te):
+ """
+ Update table areas by checking for overlaps with new text edges.
+
+ Parameters
+ ----------
+ table_areas : dict
+ Current table areas to be updated.
+ te : object
+ The new text edge object to check for overlaps.
+
+ Returns
+ -------
+ None
+ """
+ found = None
+ for area in table_areas:
+ # Check for overlap
+ if te.y1 >= area[1] and te.y0 <= area[3]:
+ found = area
+ break
+
+ if found is None:
+ table_areas[(te.coord, te.y0, te.coord, te.y1)] = None
+ else:
+ table_areas.pop(found)
+ updated_area = (
+ found[0],
+ min(te.y0, found[1]),
+ max(found[2], te.coord),
+ max(found[3], te.y1),
+ )
+ table_areas[updated_area] = None
+
+ def _extend_table_areas_with_textlines(self, table_areas, textlines):
+ """
+ Extend table areas based on text lines that overlap vertically.
+
+ Parameters
+ ----------
+ table_areas : dict
+ Current table areas to be extended.
+ textlines : list
+ List of text line objects relevant for extending table areas.
+
+ Returns
+ -------
+ None
+ """
  for tl in textlines:
- sum_textline_height += tl.y1 - tl.y0
  found = None
  for area in table_areas:
- # check for overlap
+ # Check for overlap
  if tl.y0 >= area[1] and tl.y1 <= area[3]:
  found = area
  break
+
  if found is not None:
  table_areas.pop(found)
  updated_area = (
@@ -321,14 +379,46 @@ def pad(area, average_row_height):
  max(found[3], tl.y1),
  )
  table_areas[updated_area] = None
- average_textline_height = sum_textline_height / float(len(textlines))
 
- # add some padding to table areas
- table_areas_padded = {}
- for area in table_areas:
- table_areas_padded[pad(area, average_textline_height)] = None
+ def _calculate_average_textline_height(self, textlines):
+ """
+ Calculate the average height of text lines.
 
- return table_areas_padded
+ Parameters
+ ----------
+ textlines : list
+ List of text line objects.
+
+ Returns
+ -------
+ float
+ The average height of the text lines.
+ """
+ sum_textline_height = sum(tl.y1 - tl.y0 for tl in textlines)
+ return sum_textline_height / float(len(textlines)) if textlines else 0
+
+ def _pad(self, area, average_row_height):
+ """
+ Pad a given area by a constant value.
+
+ Parameters
+ ----------
+ area : tuple
+ The area to be padded defined as (x0, y0, x1, y1).
+ average_row_height : float
+ The average height of rows to use for padding.
+
+ Returns
+ -------
+ tuple
+ The padded area.
+ """
+ x0 = area[0] - TABLE_AREA_PADDING
+ y0 = area[1] - TABLE_AREA_PADDING
+ x1 = area[2] + TABLE_AREA_PADDING
+ # Add a constant since table headers can be relatively up
+ y1 = area[3] + average_row_height * 5
+ return (x0, y0, x1, y1)
 
 
 class Cell: