natural-pdf 0.1.30__py3-none-any.whl → 0.1.32__py3-none-any.whl

natural_pdf/analyzers/shape_detection_mixin.py

@@ -1129,645 +1129,6 @@ class ShapeDetectionMixin:
                 )
         return final_lines_data
 
-    def detect_lines_preview(
-        self,
-        resolution: int = 72,  # Preview typically uses lower resolution
-        method: str = "projection",
-        horizontal: bool = True,
-        vertical: bool = True,
-        peak_threshold_h: float = 0.5,
-        min_gap_h: int = 5,
-        peak_threshold_v: float = 0.5,
-        min_gap_v: int = 5,
-        max_lines_h: Optional[int] = None,
-        max_lines_v: Optional[int] = None,
-        binarization_method: str = LINE_DETECTION_PARAM_DEFAULTS["binarization_method"],
-        adaptive_thresh_block_size: int = LINE_DETECTION_PARAM_DEFAULTS[
-            "adaptive_thresh_block_size"
-        ],
-        adaptive_thresh_C_val: int = LINE_DETECTION_PARAM_DEFAULTS["adaptive_thresh_C_val"],
-        morph_op_h: str = LINE_DETECTION_PARAM_DEFAULTS["morph_op_h"],
-        morph_kernel_h: Tuple[int, int] = LINE_DETECTION_PARAM_DEFAULTS["morph_kernel_h"],
-        morph_op_v: str = LINE_DETECTION_PARAM_DEFAULTS["morph_op_v"],
-        morph_kernel_v: Tuple[int, int] = LINE_DETECTION_PARAM_DEFAULTS["morph_kernel_v"],
-        smoothing_sigma_h: float = LINE_DETECTION_PARAM_DEFAULTS["smoothing_sigma_h"],
-        smoothing_sigma_v: float = LINE_DETECTION_PARAM_DEFAULTS["smoothing_sigma_v"],
-        peak_width_rel_height: float = LINE_DETECTION_PARAM_DEFAULTS["peak_width_rel_height"],
-        # LSD-specific parameters
-        off_angle: int = 5,
-        min_line_length: int = 30,
-        merge_angle_tolerance: int = 5,
-        merge_distance_tolerance: int = 3,
-        merge_endpoint_tolerance: int = 10,
-        initial_min_line_length: int = 10,
-        min_nfa_score_horizontal: float = -10.0,
-        min_nfa_score_vertical: float = -10.0,
-    ) -> Optional[Image.Image]:
-        """
-        Previews detected lines on a Page or Region without adding them to the PDF elements.
-        Generates and returns a debug visualization image.
-        This method is intended for Page or Region objects.
-
-        Args:
-            method: Detection method - "projection" (default) or "lsd" (requires opencv-python).
-            See `detect_lines` for other parameter descriptions. The main difference is a lower default `resolution`.
-
-        Returns:
-            PIL Image with line detection visualization, or None if preview failed.
-
-        Note:
-            Only projection profiling method supports histogram visualization.
-            LSD method will show detected lines overlaid on the original image.
-        """
-        if hasattr(self, "pdfs") or (hasattr(self, "pages") and not hasattr(self, "_page")):
-            logger.warning(
-                "preview_detected_lines is intended for single Page/Region objects. For collections, process pages individually."
-            )
-            return None
-
-        if not horizontal and not vertical:  # Check this early
-            logger.info("Line preview skipped as both horizontal and vertical are False.")
-            return None
-
-        # Validate method parameter
-        if method not in ["projection", "lsd"]:
-            raise ValueError(f"Invalid method '{method}'. Supported methods: 'projection', 'lsd'")
-
-        cv_image, _, _, page_object_ctx = self._get_image_for_detection(
-            resolution
-        )  # scale_factor and origin_offset not needed for preview
-        if (
-            cv_image is None or page_object_ctx is None
-        ):  # page_object_ctx for logging context mostly
-            logger.warning(f"Skipping line preview for {self} due to image error.")
-            return None
-
-        pil_image_for_dims = None
-        if hasattr(self, "to_image") and hasattr(self, "width") and hasattr(self, "height"):
-            if hasattr(self, "x0") and hasattr(self, "top") and hasattr(self, "_page"):
-                pil_image_for_dims = self.to_image(
-                    resolution=resolution, crop=True, include_highlights=False
-                )
-            else:
-                pil_image_for_dims = self.to_image(resolution=resolution, include_highlights=False)
-
-        if pil_image_for_dims is None:
-            logger.warning(
-                f"Could not render PIL image for preview for {self}. Using cv_image to create one."
-            )
-            pil_image_for_dims = Image.fromarray(cv_image)
-
-        if pil_image_for_dims.mode != "RGB":
-            pil_image_for_dims = pil_image_for_dims.convert("RGB")
-
-        # Get lines data based on method
-        if method == "projection":
-            lines_data_img, profile_h_smoothed, profile_v_smoothed = self._find_lines_on_image_data(
-                cv_image=cv_image,
-                pil_image_rgb=pil_image_for_dims,
-                horizontal=horizontal,
-                vertical=vertical,
-                peak_threshold_h=peak_threshold_h,
-                min_gap_h=min_gap_h,
-                peak_threshold_v=peak_threshold_v,
-                min_gap_v=min_gap_v,
-                max_lines_h=max_lines_h,
-                max_lines_v=max_lines_v,
-                binarization_method=binarization_method,
-                adaptive_thresh_block_size=adaptive_thresh_block_size,
-                adaptive_thresh_C_val=adaptive_thresh_C_val,
-                morph_op_h=morph_op_h,
-                morph_kernel_h=morph_kernel_h,
-                morph_op_v=morph_op_v,
-                morph_kernel_v=morph_kernel_v,
-                smoothing_sigma_h=smoothing_sigma_h,
-                smoothing_sigma_v=smoothing_sigma_v,
-                peak_width_rel_height=peak_width_rel_height,
-            )
-        elif method == "lsd":
-            try:
-                import cv2
-            except ImportError:
-                raise ImportError(
-                    "OpenCV (cv2) is required for LSD line detection preview. "
-                    "Install it with: pip install opencv-python\n"
-                    "Alternatively, use method='projection' for preview."
-                )
-            lines_data_img = self._process_image_for_lines_lsd(
-                cv_image,
-                off_angle,
-                min_line_length,
-                merge_angle_tolerance,
-                merge_distance_tolerance,
-                merge_endpoint_tolerance,
-                initial_min_line_length,
-                min_nfa_score_horizontal,
-                min_nfa_score_vertical,
-            )
-            profile_h_smoothed, profile_v_smoothed = None, None  # LSD doesn't use profiles
-
-        if not lines_data_img:  # Check if any lines were detected before visualization
-            logger.info(f"No lines detected for preview on {page_object_ctx or self}")
-            # Optionally return the base image if no lines, or None
-            return pil_image_for_dims.convert("RGBA")  # Return base image so something is shown
-
-        # --- Visualization Logic ---
-        final_viz_image: Optional[Image.Image] = None
-        viz_image_base = pil_image_for_dims.convert("RGBA")
-        draw = ImageDraw.Draw(viz_image_base)
-        img_width, img_height = viz_image_base.size
-
-        viz_params = {
-            "draw_line_thickness_viz": 2,  # Slightly thicker for better visibility
-            "debug_histogram_size": 100,
-            "line_color_h": (255, 0, 0, 200),
-            "line_color_v": (0, 0, 255, 200),
-            "histogram_bar_color_h": (200, 0, 0, 200),
-            "histogram_bar_color_v": (0, 0, 200, 200),
-            "histogram_bg_color": (240, 240, 240, 255),
-            "padding_between_viz": 10,
-            "peak_threshold_h": peak_threshold_h,
-            "peak_threshold_v": peak_threshold_v,
-            "max_lines_h": max_lines_h,
-            "max_lines_v": max_lines_v,
-        }
-
-        # Draw detected lines on the image
-        for line_info in lines_data_img:
-            is_h_line = abs(line_info["y1"] - line_info["y2"]) < abs(
-                line_info["x1"] - line_info["x2"]
-            )
-            line_color = viz_params["line_color_h"] if is_h_line else viz_params["line_color_v"]
-            draw.line(
-                [(line_info["x1"], line_info["y1"]), (line_info["x2"], line_info["y2"])],
-                fill=line_color,
-                width=viz_params["draw_line_thickness_viz"],
-            )
-
-        # For projection method, add histogram visualization
-        if method == "projection" and (
-            profile_h_smoothed is not None or profile_v_smoothed is not None
-        ):
-            hist_size = viz_params["debug_histogram_size"]
-            hist_h_img = Image.new(
-                "RGBA", (hist_size, img_height), viz_params["histogram_bg_color"]
-            )
-            hist_h_draw = ImageDraw.Draw(hist_h_img)
-
-            if profile_h_smoothed is not None and profile_h_smoothed.size > 0:
-                actual_max_h_profile = profile_h_smoothed.max()
-                display_threshold_val_h = peak_threshold_h * img_width
-                # Use the maximum of either the profile max or threshold for scaling, so both are always visible
-                max_h_profile_val_for_scaling = (
-                    max(actual_max_h_profile, display_threshold_val_h)
-                    if actual_max_h_profile > 0
-                    else img_width
-                )
-                for y_coord, val in enumerate(profile_h_smoothed):
-                    bar_len = 0
-                    thresh_bar_len = 0
-                    if max_h_profile_val_for_scaling > 0:
-                        bar_len = int((val / max_h_profile_val_for_scaling) * hist_size)
-                        if display_threshold_val_h >= 0:
-                            thresh_bar_len = int(
-                                (display_threshold_val_h / max_h_profile_val_for_scaling)
-                                * hist_size
-                            )
-                    bar_len = min(max(0, bar_len), hist_size)
-                    if bar_len > 0:
-                        hist_h_draw.line(
-                            [(0, y_coord), (bar_len - 1, y_coord)],
-                            fill=viz_params["histogram_bar_color_h"],
-                            width=1,
-                        )
-                    if (
-                        viz_params["max_lines_h"] is None
-                        and display_threshold_val_h >= 0
-                        and thresh_bar_len > 0
-                        and thresh_bar_len <= hist_size
-                    ):
-                        # Ensure threshold line is within bounds
-                        thresh_x = min(thresh_bar_len, hist_size - 1)
-                        hist_h_draw.line(
-                            [
-                                (thresh_x, y_coord),
-                                (thresh_x, y_coord + 1 if y_coord + 1 < img_height else y_coord),
-                            ],
-                            fill=(0, 255, 0, 100),
-                            width=1,
-                        )
-
-            hist_v_img = Image.new("RGBA", (img_width, hist_size), viz_params["histogram_bg_color"])
-            hist_v_draw = ImageDraw.Draw(hist_v_img)
-            if profile_v_smoothed is not None and profile_v_smoothed.size > 0:
-                actual_max_v_profile = profile_v_smoothed.max()
-                display_threshold_val_v = peak_threshold_v * img_height
-                # Use the maximum of either the profile max or threshold for scaling, so both are always visible
-                max_v_profile_val_for_scaling = (
-                    max(actual_max_v_profile, display_threshold_val_v)
-                    if actual_max_v_profile > 0
-                    else img_height
-                )
-                for x_coord, val in enumerate(profile_v_smoothed):
-                    bar_height = 0
-                    thresh_bar_h = 0
-                    if max_v_profile_val_for_scaling > 0:
-                        bar_height = int((val / max_v_profile_val_for_scaling) * hist_size)
-                        if display_threshold_val_v >= 0:
-                            thresh_bar_h = int(
-                                (display_threshold_val_v / max_v_profile_val_for_scaling)
-                                * hist_size
-                            )
-                    bar_height = min(max(0, bar_height), hist_size)
-                    if bar_height > 0:
-                        hist_v_draw.line(
-                            [(x_coord, hist_size - 1), (x_coord, hist_size - bar_height)],
-                            fill=viz_params["histogram_bar_color_v"],
-                            width=1,
-                        )
-                    if (
-                        viz_params["max_lines_v"] is None
-                        and display_threshold_val_v >= 0
-                        and thresh_bar_h > 0
-                        and thresh_bar_h <= hist_size
-                    ):
-                        # Ensure threshold line is within bounds
-                        thresh_y = min(thresh_bar_h, hist_size - 1)
-                        hist_v_draw.line(
-                            [
-                                (x_coord, hist_size - thresh_y),
-                                (
-                                    x_coord + 1 if x_coord + 1 < img_width else x_coord,
-                                    hist_size - thresh_y,
-                                ),
-                            ],
-                            fill=(0, 255, 0, 100),
-                            width=1,
-                        )
-
-            padding = viz_params["padding_between_viz"]
-            total_width = img_width + padding + hist_size
-            total_height = img_height + padding + hist_size
-            final_viz_image = Image.new("RGBA", (total_width, total_height), (255, 255, 255, 255))
-            final_viz_image.paste(viz_image_base, (0, 0))
-            final_viz_image.paste(hist_h_img, (img_width + padding, 0))
-            final_viz_image.paste(hist_v_img, (0, img_height + padding))
-        else:
-            # For LSD method, just return the image with lines overlaid
-            final_viz_image = viz_image_base
-
-        logger.info(f"Generated line preview visualization for {page_object_ctx or self}")
-        return final_viz_image
-
-    def detect_table_structure_from_lines(
-        self,
-        source_label: str = "detected",
-        ignore_outer_regions: bool = True,
-        cell_padding: float = 0.5,  # Small padding inside cells, default to 0.5px
-    ) -> "ShapeDetectionMixin":
-        """
-        Create table structure (rows, columns, cells) from previously detected lines.
-
-        This method analyzes horizontal and vertical lines to create a grid structure,
-        then generates Region objects for:
-        - An overall table region that encompasses the entire table structure
-        - Individual row regions spanning the width of the table
-        - Individual column regions spanning the height of the table
-        - Individual cell regions at each row/column intersection
-
-        Args:
-            source_label: Filter lines by this source label (from detect_lines)
-            ignore_outer_regions: If True, don't create regions outside the defined by lines grid.
-                                  If False, include regions from page/object edges to the first/last lines.
-            cell_padding: Internal padding for cell regions
-
-        Returns:
-            Self for method chaining
-        """
-        # Handle collections
-        if hasattr(self, "pdfs"):
-            for pdf_doc in self.pdfs:
-                for page_obj in pdf_doc.pages:
-                    page_obj.detect_table_structure_from_lines(
-                        source_label=source_label,
-                        ignore_outer_regions=ignore_outer_regions,
-                        cell_padding=cell_padding,
-                    )
-            return self
-        elif hasattr(self, "pages") and not hasattr(self, "_page"):  # PageCollection
-            for page_obj in self.pages:
-                page_obj.detect_table_structure_from_lines(
-                    source_label=source_label,
-                    ignore_outer_regions=ignore_outer_regions,
-                    cell_padding=cell_padding,
-                )
-            return self
-
-        # Determine context (Page or Region) for coordinates and element management
-        page_object_for_elements = None
-        origin_x, origin_y = 0.0, 0.0
-        context_width, context_height = 0.0, 0.0
-
-        if (
-            hasattr(self, "_element_mgr") and hasattr(self, "width") and hasattr(self, "height")
-        ):  # Likely a Page
-            page_object_for_elements = self
-            context_width = self.width
-            context_height = self.height
-            logger.debug(f"Operating on Page context: {self}")
-        elif (
-            hasattr(self, "_page") and hasattr(self, "x0") and hasattr(self, "width")
-        ):  # Likely a Region
-            page_object_for_elements = self._page
-            origin_x = self.x0
-            origin_y = self.top
-            context_width = self.width  # Region's own width/height for its boundary calculations
-            context_height = self.height
-            logger.debug(f"Operating on Region context: {self}, origin: ({origin_x}, {origin_y})")
-        else:
-            logger.warning(
-                f"Could not determine valid page/region context for {self}. Aborting table structure detection."
-            )
-            return self
-
-        element_manager = page_object_for_elements._element_mgr
-
-        # ------------------------------------------------------------------
-        # CLEAN-UP existing table-related regions from earlier runs to avoid duplicates
-        # ------------------------------------------------------------------
-        try:
-            _purge_types = {"table", "table_row", "table_column", "table_cell"}
-
-            if (
-                hasattr(element_manager, "_elements")
-                and "regions" in element_manager._elements
-            ):
-                _orig_len = len(element_manager._elements["regions"])
-                element_manager._elements["regions"] = [
-                    r
-                    for r in element_manager._elements["regions"]
-                    if not (
-                        getattr(r, "source", None) == source_label
-                        and getattr(r, "region_type", None) in _purge_types
-                    )
-                ]
-                _removed = _orig_len - len(element_manager._elements["regions"])
-                if _removed:
-                    logger.info(
-                        f"Removed {_removed} previous table-related regions (source='{source_label}') before regeneration."
-                    )
-
-            if hasattr(page_object_for_elements, "_regions") and "detected" in page_object_for_elements._regions:
-                page_object_for_elements._regions["detected"] = [
-                    r
-                    for r in page_object_for_elements._regions["detected"]
-                    if not (
-                        getattr(r, "source", None) == source_label
-                        and getattr(r, "region_type", None) in _purge_types
-                    )
-                ]
-        except Exception as _cleanup_err:
-            logger.warning(
-                f"Table-region cleanup failed: {_cleanup_err}", exc_info=True
-            )
-
-        # Get lines with the specified source
-        all_lines = element_manager.lines  # Access lines from the correct element manager
-        filtered_lines = [
-            line for line in all_lines if getattr(line, "source", None) == source_label
-        ]
-
-        if not filtered_lines:
-            logger.info(
-                f"No lines found with source '{source_label}' for table structure detection on {self}."
-            )
-            return self
-
-        # Separate horizontal and vertical lines
-        # For regions, line coordinates are already absolute to the page.
-        horizontal_lines = [line for line in filtered_lines if line.is_horizontal]
-        vertical_lines = [line for line in filtered_lines if line.is_vertical]
-
-        logger.info(
-            f"Found {len(horizontal_lines)} horizontal and {len(vertical_lines)} vertical lines for {self} with source '{source_label}'."
-        )
-
-        # Define boundaries based on line positions (mid-points for sorting, actual edges for boundaries)
-        # These coordinates are relative to the page_object_for_elements (which is always a Page)
-
-        # Horizontal line Y-coordinates (use average y, effectively the line's y-position)
-        h_line_ys = sorted(list(set([(line.top + line.bottom) / 2 for line in horizontal_lines])))
-
-        # Vertical line X-coordinates (use average x, effectively the line's x-position)
-        v_line_xs = sorted(list(set([(line.x0 + line.x1) / 2 for line in vertical_lines])))
-
-        row_boundaries = []
-        if horizontal_lines:
-            if not ignore_outer_regions:
-                row_boundaries.append(origin_y)  # Region's top or Page's 0
-            row_boundaries.extend(h_line_ys)
-            if not ignore_outer_regions:
-                row_boundaries.append(origin_y + context_height)  # Region's bottom or Page's height
-        elif not ignore_outer_regions:  # No horizontal lines, but we might want full height cells
-            row_boundaries.extend([origin_y, origin_y + context_height])
-        row_boundaries = sorted(list(set(row_boundaries)))
-
-        col_boundaries = []
-        if vertical_lines:
-            if not ignore_outer_regions:
-                col_boundaries.append(origin_x)  # Region's left or Page's 0
-            col_boundaries.extend(v_line_xs)
-            if not ignore_outer_regions:
-                col_boundaries.append(origin_x + context_width)  # Region's right or Page's width
-        elif not ignore_outer_regions:  # No vertical lines, but we might want full width cells
-            col_boundaries.extend([origin_x, origin_x + context_width])
-        col_boundaries = sorted(list(set(col_boundaries)))
-
-        logger.debug(f"Row boundaries for {self}: {row_boundaries}")
-        logger.debug(f"Col boundaries for {self}: {col_boundaries}")
-
-        # Create overall table region that wraps the entire structure
-        tables_created = 0
-        if len(row_boundaries) >= 2 and len(col_boundaries) >= 2:
-            table_left = col_boundaries[0]
-            table_top = row_boundaries[0]
-            table_right = col_boundaries[-1]
-            table_bottom = row_boundaries[-1]
-
-            if table_right > table_left and table_bottom > table_top:
-                try:
-                    table_region = page_object_for_elements.create_region(
-                        table_left, table_top, table_right, table_bottom
-                    )
-                    table_region.source = source_label
-                    table_region.region_type = "table"
-                    table_region.normalized_type = (
-                        "table"  # Add normalized_type for selector compatibility
-                    )
-                    table_region.metadata.update(
-                        {
-                            "source_lines_label": source_label,
-                            "num_rows": len(row_boundaries) - 1,
-                            "num_cols": len(col_boundaries) - 1,
-                            "boundaries": {"rows": row_boundaries, "cols": col_boundaries},
-                        }
-                    )
-                    element_manager.add_element(table_region, element_type="regions")
-                    tables_created += 1
-                    logger.debug(
-                        f"Created table region: L{table_left:.1f} T{table_top:.1f} R{table_right:.1f} B{table_bottom:.1f}"
-                    )
-                except Exception as e:
-                    logger.error(
-                        f"Failed to create or add table Region: {e}. Table abs coords: L{table_left} T{table_top} R{table_right} B{table_bottom}",
-                        exc_info=True,
-                    )
-
-        # Create cell regions
-        cells_created = 0
-        rows_created = 0
-        cols_created = 0
-
-        # Create Row Regions
-        if len(row_boundaries) >= 2:
-            # Determine horizontal extent for rows
-            row_extent_x0 = origin_x
-            row_extent_x1 = origin_x + context_width
-            if col_boundaries:  # If columns are defined, rows should span only across them
-                if len(col_boundaries) >= 2:
-                    row_extent_x0 = col_boundaries[0]
-                    row_extent_x1 = col_boundaries[-1]
-                # If only one col_boundary (e.g. from ignore_outer_regions=False and one line), use context width
-                # This case should be rare if lines are properly detected to form a grid.
-
-            for i in range(len(row_boundaries) - 1):
-                top_abs = row_boundaries[i]
-                bottom_abs = row_boundaries[i + 1]
-
-                # Use calculated row_extent_x0 and row_extent_x1
-                if bottom_abs > top_abs and row_extent_x1 > row_extent_x0:  # Ensure valid region
-                    try:
-                        row_region = page_object_for_elements.create_region(
-                            row_extent_x0, top_abs, row_extent_x1, bottom_abs
-                        )
-                        row_region.source = source_label
-                        row_region.region_type = "table_row"
-                        row_region.normalized_type = (
-                            "table_row"  # Add normalized_type for selector compatibility
-                        )
-                        row_region.metadata.update(
-                            {"row_index": i, "source_lines_label": source_label}
-                        )
-                        element_manager.add_element(row_region, element_type="regions")
-                        rows_created += 1
-                    except Exception as e:
-                        logger.error(
-                            f"Failed to create or add table_row Region: {e}. Row abs coords: L{row_extent_x0} T{top_abs} R{row_extent_x1} B{bottom_abs}",
-                            exc_info=True,
-                        )
-
-        # Create Column Regions
-        if len(col_boundaries) >= 2:
-            # Determine vertical extent for columns
-            col_extent_y0 = origin_y
-            col_extent_y1 = origin_y + context_height
-            if row_boundaries:  # If rows are defined, columns should span only across them
-                if len(row_boundaries) >= 2:
-                    col_extent_y0 = row_boundaries[0]
-                    col_extent_y1 = row_boundaries[-1]
-                # If only one row_boundary, use context height - similar logic to rows
-
-            for j in range(len(col_boundaries) - 1):
-                left_abs = col_boundaries[j]
-                right_abs = col_boundaries[j + 1]
-
-                # Use calculated col_extent_y0 and col_extent_y1
-                if right_abs > left_abs and col_extent_y1 > col_extent_y0:  # Ensure valid region
-                    try:
-                        col_region = page_object_for_elements.create_region(
-                            left_abs, col_extent_y0, right_abs, col_extent_y1
-                        )
-                        col_region.source = source_label
-                        col_region.region_type = "table_column"
-                        col_region.normalized_type = (
-                            "table_column"  # Add normalized_type for selector compatibility
-                        )
-                        col_region.metadata.update(
-                            {"col_index": j, "source_lines_label": source_label}
-                        )
-                        element_manager.add_element(col_region, element_type="regions")
-                        cols_created += 1
-                    except Exception as e:
-                        logger.error(
-                            f"Failed to create or add table_column Region: {e}. Col abs coords: L{left_abs} T{col_extent_y0} R{right_abs} B{col_extent_y1}",
-                            exc_info=True,
-                        )
-
-        # Create Cell Regions (existing logic)
-        if len(row_boundaries) < 2 or len(col_boundaries) < 2:
-            logger.info(
-                f"Not enough boundaries to form cells for {self}. Rows: {len(row_boundaries)}, Cols: {len(col_boundaries)}"
-            )
-            # return self # Return will be at the end
-        else:
-            for i in range(len(row_boundaries) - 1):
-                top_abs = row_boundaries[i]
-                bottom_abs = row_boundaries[i + 1]
-
-                for j in range(len(col_boundaries) - 1):
-                    left_abs = col_boundaries[j]
-                    right_abs = col_boundaries[j + 1]
-
-                    cell_left_abs = left_abs + cell_padding
-                    cell_top_abs = top_abs + cell_padding
-                    cell_right_abs = right_abs - cell_padding
-                    cell_bottom_abs = bottom_abs - cell_padding
-
-                    cell_width = cell_right_abs - cell_left_abs
-                    cell_height = cell_bottom_abs - cell_top_abs
-
-                    if cell_width <= 0 or cell_height <= 0:
-                        logger.debug(
-                            f"Skipping cell (zero or negative dimension after padding): L{left_abs:.1f} T{top_abs:.1f} R{right_abs:.1f} B{bottom_abs:.1f} -> W{cell_width:.1f} H{cell_height:.1f}"
-                        )
-                        continue
-
-                    try:
-                        cell_region = page_object_for_elements.create_region(
-                            cell_left_abs, cell_top_abs, cell_right_abs, cell_bottom_abs
-                        )
-                        cell_region.source = source_label
-                        cell_region.region_type = "table_cell"
-                        cell_region.normalized_type = (
-                            "table_cell"  # Add normalized_type for selector compatibility
-                        )
-                        cell_region.metadata.update(
-                            {
-                                "row_index": i,
-                                "col_index": j,
-                                "source_lines_label": source_label,
-                                "original_boundaries_abs": {
-                                    "left": left_abs,
-                                    "top": top_abs,
-                                    "right": right_abs,
-                                    "bottom": bottom_abs,
-                                },
-                            }
-                        )
-                        element_manager.add_element(cell_region, element_type="regions")
-                        cells_created += 1
-                    except Exception as e:
-                        logger.error(
-                            f"Failed to create or add cell Region: {e}. Cell abs coords: L{cell_left_abs} T{cell_top_abs} R{cell_right_abs} B{cell_bottom_abs}",
-                            exc_info=True,
-                        )
-
-        logger.info(
-            f"Created {tables_created} table, {rows_created} rows, {cols_created} columns, and {cells_created} table cells from detected lines (source: '{source_label}') for {self}."
-        )
-
-        return self
-
     def detect_blobs(
         self,
         k: Optional[int] = None,
@@ -1993,14 +1354,3 @@ class ShapeDetectionMixin:
                 page_obj._element_mgr.add_region(region)
 
         return self
-
-
-# Example usage would be:
-# page.detect_lines(source_label="my_table_lines")
-# page.detect_table_structure_from_lines(source_label="my_table_lines", cell_padding=0.5)
-#
-# Now both selector styles work equivalently:
-# table = page.find('table[source*="table_from"]')  # Direct type selector
-# table = page.find('region[type="table"][source*="table_from"]')  # Region attribute selector
-# cells = page.find_all('table-cell[source*="table_cells_from"]')  # Direct type selector
-# cells = page.find_all('region[type="table-cell"][source*="table_cells_from"]')  # Region attribute selector