/j-jj0SrSSKrSSKrSSKJr SSKJr SSKJr SrSr S#Sjr S$S jr S r S r S%S jrS rSrSrSrSrSrSrSrS&Sjr\4SjrSrSrSrSr\4Sjr"SS5rSrSr \4Sjr!\4S jr"\4S!jr#Sr$\$4S"jr%g)'zpFunctions useful for detecting graphical elements from the image to using OpenCV to reconstruct / detect tables.N) LTContainer)LTLine)LTRectgMb@?cUS:Xa%[R"U[R5$US:Xa%[R"U[R5$U$)aJUndo rotation of an image extracted from a PDF. Parameters ---------- pdf_image: numpy.ndarray representing the image. rotation: str Either "" (no rotation), "clockwise", or "anticlockwise". The **inverse** of this rotation will be applied to the image. Returns ------- img: numpy.ndarray representing the rotated image. clockwise anticlockwise)cv2rotateROTATE_90_COUNTERCLOCKWISEROTATE_90_CLOCKWISE) pdf_imagerotations U/home/mande/repo/quber/.venv/lib/python3.13/site-packages/camelot/image_processing.py undo_rotationrsH;zz)S%C%CDD?"zz)S%<%<== c|[U[R5(aUO[R"U5n[ XT5n[R "U[R5nU(d[R"U5n[R"US[R[RX#5nXW4$)u1Thresholds an image using OpenCV's adaptiveThreshold. Parameters ---------- imagename : str or numpy.ndarray Path to an image file, or an already-decoded BGR image array (the latter lets callers skip the PNG round-trip — see #40). process_background : bool, optional (default: False) Whether or not to process lines that are in background. blocksize : int, optional (default: 15) Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on. For more information, refer `OpenCV's adaptiveThreshold `_. c : int, optional (default: -2) Constant subtracted from the mean or weighted mean. Normally, it is positive but may be zero or negative as well. For more information, refer `OpenCV's adaptiveThreshold `_. rotation: str, optional (default: "") Either "" (no rotation), "clockwise", or "anticlockwise". The **inverse** of this rotation will be applied to the image. Returns ------- img : object numpy.ndarray representing the original image. threshold : object numpy.ndarray representing the thresholded image. ) isinstancenpndarrayr imreadrcvtColorCOLOR_BGR2GRAYinvertadaptiveThresholdADAPTIVE_THRESH_GAUSSIAN_C THRESH_BINARY) imagenameprocess_background blocksizecrimggray thresholds radaptive_thresholdr%(sF")RZZ88)cjj>SC  &C <<S// 0D yy%% c31133D3DiI >rc0US;a [S5e[XU5upg[X5n[XXE5n[R "UR [R5[R[R5up[X5n X4$)u  Finds horizontal and vertical lines by applying morphological transformations on an image. Parameters ---------- threshold : object numpy.ndarray representing the thresholded image. regions : list, optional (default: None) List of page regions that may contain tables of the form x1,y1,x2,y2 where (x1, y1) -> left-top and (x2, y2) -> right-bottom in image coordinate space. direction : string, optional (default: 'horizontal') Specifies whether to find vertical or horizontal lines. line_scale : int, optional (default: 40) Factor by which the page dimensions will be divided to get smallest length of lines that should be detected. iterations : int, optional (default: 0) Number of dilation passes applied to close small gaps in the line mask. Useful for tables whose ruled lines don't quite meet at corners. erode_iterations : int, optional (default: 0) Number of erosion passes applied **after** dilation. Set equal to ``iterations`` to perform morphological *closing* (dilate then erode of equal count): gaps are closed without enlarging the line mask overall. Requested in #363 — previously the erode step was missing, so ``iterations>=1`` widened every line and added phantom top/bottom lines around tables. Returns ------- dmask : object numpy.ndarray representing pixels where vertical/horizontal lines lie. lines : list List of tuples representing vertical/horizontal lines with coordinates relative to a left-top origin in image coordinate space. )vertical horizontalz6Specify direction as either 'vertical' or 'horizontal') ValueErrorcreate_structuring_elementapply_region_mask process_imager findContoursastyperuint8 RETR_EXTERNALCHAIN_APPROX_SIMPLEextract_lines_from_contours) r$regions direction line_scale iterationserode_iterationselsizeprocessed_thresholdcontours_liness r find_linesr>Vs\22QRR)) KHB!)5I' zT""""288,c.?.?AXAXKH ( left-top, w -> width and h -> height in image coordinate space. rr@g?T)keyreverse)r r-r.rr/r0r1floatrA_MIN_TABLE_AREA_FRACTIONsorted contourArea approxPolyDPrTrU)r'r(maskr;__ page_areamin_arear!contc_polyrJrKrLrMs r find_contoursris$  D## BHHs00#2I2ILHdjjmdjjm34;I33HhCOOTBH#F8asq'9X'E8HF D !!!Q-%%f- a Q1L! KGs /D*D*c[R"X5n0nUHnUupgpX7Xy-2XfU-24n [R"U R [R 5[R [R5up[U 5S::aMz/n U HMn[R"U5unnnnUSU-U-S--USU-U-S--nnU RUU45 MO XXgU -Xh-U4'M U$)aFind joints/intersections present inside each table boundary. Parameters ---------- contours : list List of tuples representing table boundaries. Each tuple is of the form (x, y, w, h) where (x, y) -> left-top, w -> width and h -> height in image coordinate space. vertical : object numpy.ndarray representing pixels where vertical lines lie. horizontal : object numpy.ndarray representing pixels where horizontal lines lie. Returns ------- tables : dict Dict with table boundaries as keys and list of intersections in that boundary as their value. Keys are of the form (x1, y1, x2, y2) where (x1, y1) -> lb and (x2, y2) -> rt in image coordinate space. rS) rrGr r-r.r/ RETR_CCOMPr1lenrTrU)r;r'r(jointstablesr!rJrKrLrMroijcrd joint_coordsjjxjyjwjhc1c2s r find_jointsrz0s.[[ .F F  aYE )*!! JJrxx #..#2I2I  r7a<  A --a0NBB!b&2+!++Q!b&2+!1C-CB   R )(4q5!%#$ Mrg?@g?c#~# UH1nUv [U[5(dM[U5ShvN M3 gN 7f)z9Recursively yield every object in an LTContainer subtree.N)rr_walk_layout_objects) containerobjs rr}r}us4 c; ' '+C0 0 0 1s==; =cJ/n[U5GHn[U[5(aQ[USS5(a?UR UR UR URUR45 Mj[U[5(dM[USS5n[USS5nU(aUR UR UR URUR 45 UR UR URURUR45 UR UR UR UR UR45 UR URUR URUR45 GMU(dGMURUR - nURUR - n[XV5[::dGM[XV5[:dGMXV:aGUR UR-S- nUR UR XrRU45 GMMUR UR-S- nUR XR XR45 GM U$)aGCollect ruled line segments from a layout tree (PDF coord space). Returns a list of ``(x0, y0, x1, y1)`` tuples. Both stroked LTLines and the four edges of stroked LTRects are emitted. Filled-but-not- stroked LTRects with one narrow dimension are also treated as lines (covers PDFs that draw rules as thin filled rectangles). strokeTFfillrS) r}rrgetattrrUx0y0rVrXrmin_LINE_AS_THIN_RECT_TOLmax) layoutoutrstrokedfilledwidthheightmid_ymid_xs r_ruled_lines_from_layoutr}s46C#F+ c6 " "wsHd'C'C JJ7 8 V $ $c8U3GS&%0F CFFCFFCFFCFF;< CFFCFFCFFCFF;< CFFCFFCFFCFF;< CFFCFFCFFCFF;<#&&&*@@E*-CC!$#&&A 5 CFFE665#AB!$#&&A 5 E665&&#AB3,4 Jrc US;a [S5e[U5n/nUHupEpg[Xd- 5n[Xu- 5n US:Xa9U [::a/US:a)UR [ XF5U[ XF5U45 M_US:XdMgU[::dMsU S:dM{UR U[ XW5U[ XW545 M [X15$)u Return ruled lines from a playa layout tree (Stage 1 of #763). Drop-in companion to :func:`find_lines` for ``flavor='lattice'``'s vector engine. Walks ``layout`` (recursively), classifies each LTLine / stroked LTRect / thin filled LTRect into horizontal or vertical based on its dominant axis, and returns the subset matching ``direction``. Parameters ---------- layout : object An ``LTPage`` / ``LTContainer`` from ``playa`` — typically what the lattice parser already stores on ``self.layout``. direction : str, optional (default: 'horizontal') ``'horizontal'`` returns lines whose y-delta is below the orthogonality tolerance; ``'vertical'`` returns those whose x-delta is below it. Returns ------- lines : list[tuple[float, float, float, float]] Each tuple is ``(x0, y0, x1, y1)`` in PDF coordinate space — same shape as :func:`find_lines`'s second return value, but in PDF coords (not image coords). The Lattice integration in Stage 2 will apply the existing ``scale_pdf`` to convert. Notes ----- The output drops the morphological mask :func:`find_lines` produces as its first return; the vector engine doesn't need it because it bypasses :func:`find_contours` (which is the only consumer of the mask) and computes table bboxes from line intersections directly. r(r',direction must be 'horizontal' or 'vertical'r(rr')r)rabs_LINE_ORTHOGONAL_TOLrUrrcoalesce_collinear_lines) rr4rawresultrrrVrXdxdys rfind_lines_from_layoutrsD22GHH "6 *C68F \ \  $/C)CQ MM3r;CK< = * $/C)CQ MM2s2{BB < =  $F 66rcUS;a [S5eU(d/$[X5n/nUHkupVnU(aFXTSS- U::a8USSRU5 USSRXg45 XTSS'MSURU/Xg4/US.5 Mm /nUH^n [U S5[ U S5- n[ [ U S5U5H"upgURUS:XaXeXu4OXVXW45 M$ M` U$) a|Merge near-collinear ruled-line segments into single lines. PDFs frequently draw one logical rule as a chain of short sub-segments; left unmerged they make :func:`find_joints_from_lines` under-count joints and miss grids. Segments are grouped by their constant axis (within ``tol``) and, within a group, those whose extents overlap or sit within ``tol`` of each other are fused. Parameters ---------- lines : list[tuple[float, float, float, float]] ``(x0, y0, x1, y1)`` segments, as produced by :func:`find_lines_from_layout`. direction : str ``'horizontal'`` (segments share a constant ``y``, merge along ``x``) or ``'vertical'`` (constant ``x``, merge along ``y``). tol : float, optional Merge tolerance in PDF units (default :data:`_LINE_COALESCE_TOL`). Returns ------- list[tuple[float, float, float, float]] The merged segments, same tuple shape as the input. rrlastconsts intervals)rrrr()r)_coalesce_normaliserUsumrm _merge_spansr`) r=r4tolnormclustersconstlohirclusters rrrs&222GHH  u 0DH 2  V 44; RL " ) )% 0 RL % , ,bX 6#(RL OOwrhZQVW X  CGH%&WX->)??"6'+*>#?EFB JJ ,B&+ F Jrc/nUHHup4pVUS:XaXF-S- nX5::aX54OXS4upOX5-S- nXF::aXF4OXd4upURXxU 45 MJ UR5 U$)zBReduce each segment to ``(const_axis, span_lo, span_hi)``, sorted.r(r{)rUsort) r=r4rrrrVrXrrrs rrr sw D  $WOE!#bXxFBWOE!#bXxFB UO$  IIK Krc[US5/nUSSH?up4X2SSU-::a[USSU5USS'M-URX4/5 MA U$)z:Merge overlapping / within-``tol`` ``(lo, hi)`` intervals.rr@Nr)listrrU)rrmergedrrs rrrsi9Q< !FAB- A$ $r 1 r2F2JqM MM2( #  MrrkcUup4pVUupxpiX5::aX54OXS4upX::aX4OX4upX- Us=::aX-::aO gX- Us=::a X-::aXt4$ gg)aReturn the (x, y) crossing of a horizontal and vertical line, or None. ``h_line`` is ``(x0, y, x1, y)`` (constant y), ``v_line`` is ``(x, y0, x, y1)`` (constant x), both in PDF coords as produced by :func:`find_lines_from_layout`. They cross when the vertical line's x falls within the horizontal line's x-span and the horizontal line's y falls within the vertical line's y-span, each within ``tol``. N)h_linev_linerhx0hyhx1r<vxvy0vy1x_lox_hiy_loy_his r_line_crossingr.soOCSOBQ"z#zJD"z#zJD r)dj) 04zb.PTZ.Px/Q rc*\rSrSrSrSrSrSrSrg) _UnionFindi@zDMinimal union-find with path-halving, for clustering crossing lines.c6[[U55UlgN)rrangeparent)selfns r__init___UnionFind.__init__Cs58n rcURUU:waMURURUURU'URUnURUU:waMMU$rr)ris rfind_UnionFind.findFsVkk!n!![[Q8DKKN AAkk!n!rcnURU5URU5pCX4:waX@RU'ggr)rr)rabrarbs runion_UnionFind.unionLs.1tyy|B 8 KKO rrN) __name__ __module__ __qualname____firstlineno____doc__rrr__static_attributes__rrrrr@sN% !rrc[U5n[U[U5-5n0n[U5HCupg[U5H/up[XyU5n U cMUR XcU-5 XXh4'M1 ME XE4$)a&Union-find over crossing h/v lines. Returns ``(uf, crossings)`` where ``uf`` is a :class:`_UnionFind` spanning ``[0, n_h)`` horizontal + ``[n_h, n_h+n_v)`` vertical line indices, joined wherever an h-line crosses a v-line, and ``crossings`` maps ``(h_idx, v_idx)`` to the ``(x, y)`` crossing. )rmr enumeraterr) horizontal_linesvertical_linesrn_huf crossingsrrMvivpts r_line_crossingsrRs  C C#n-- .BI+,~.EBc*B~2X&&(2(# /- =rcUVVs/sHo3SUS4HoDPM M snnUVs/sHo3SPM sn-nUVVs/sHo3SUS4HoDPM M snnUVs/sHo3SPM sn-nU(aU(dg[U5[U5[U5[U54U4$s snnfs snfs snnfs snf)zDBounding box ``((x0, y0, x1, y1), joints)`` over a cluster, or None.rrSr@r]N)rr)hsvsrnlnr!xsyss r _cluster_bboxrfs 1ba5"Q%.Q!.!b 1R4HRrUR4H HB 1ba5"Q%.Q!.!b 1R4HRrUR4H HB R Wc"gs2wB 0& 99 24H 14HsB2B8B=$Cc[U5n[XU5upE0n0n0n[U5H5n URUR U 5/5R X 5 M7 [[U55H7n URUR X:-5/5R X5 M9 UR 5H8uupn URUR U 5/5R U 5 M: /n UR 5H]up[U5[::aM[URU/5URU/5U5nUcMLU R U5 M_ U $)uGroup mutually-intersecting lines into table clusters (union-find). Returns a list of ``(bbox, joints)`` tuples — one per connected component of crossing lines — where ``bbox`` is ``(x0, y0, x1, y1)`` (left, bottom, right, top in PDF coords) and ``joints`` is the list of ``(x, y)`` crossing points within that component. Clusters with ``<= _MIN_JOINTS`` crossings are dropped (noise / stray L-corners), matching the raster pipeline's joint-count filter. This is the vector-native replacement for the raster ``find_contours`` + ``find_joints`` pair: instead of one bbox over the union of every line (the Stage-1 prototype's flaw, which merged separate tables), it isolates each grid as its own component, so multi-table pages yield multiple bboxes. ) rmrr setdefaultrrUitems _MIN_JOINTSrget)rrrrrrcomp_hcomp_v comp_jointsrr_virrrootrnrs r_cluster_linesrosA  C#$4cJMB F FKCj"''"+r*112B2FGC'("''#(+R0778JK)"* 2rwwr{B/66r:+H#))+  v;+ %  4 4fjjr6JFS   OOG $ , Orcv[XU5nUVVs/sHupEUPM nnnURSS9 U$s snnf)uCVector-native table-bbox detection (Stage 2 of #763). Companion to the raster :func:`find_contours`. Given ruled lines in PDF coords (from :func:`find_lines_from_layout`), returns a list of ``(x0, y0, x1, y1)`` table bounding boxes — one per connected cluster of mutually-intersecting lines — so a page with two separate tables yields two bboxes (the Stage-1 prototype merged them). Returns ------- list[tuple[float, float, float, float]] ``(x0, y0, x1, y1)`` = (left, bottom, right, top) in PDF coords, sorted top-to-bottom (descending y0) to match reading order. cUS*$)Nr@r)rs r*find_contours_from_lines..s qter)r[)rr)rrrrbboxr<bboxess rfind_contours_from_linesrs?.DH"* +(wtd(F + KKOK$ M,s5cP[XU5VVs0sHup4X4_M snn$s snnf)uVector-native joint detection (Stage 2 of #763). Companion to the raster :func:`find_joints`. Returns a dict keyed by table bbox ``(x0, y0, x1, y1)`` (left, bottom, right, top in PDF coords) whose value is the list of ``(x, y)`` line intersections in that table — the same shape the raster pipeline feeds into cell construction, but computed exactly from vector geometry instead of ``np.multiply`` of two rasterised masks. )r)rrrrrns rfind_joints_from_linesrs5++;SQ QLD Q  s"c8Ucg[[U55U:$)uProbe whether a layout carries enough vector ruled lines. Used by ``flavor='lattice'``'s ``engine='auto'`` to decide between the vector and raster line-detection paths (#763). Returns ``True`` when the layout tree contains at least ``min_lines`` stroked ``LTLine`` / ``LTRect`` edges (via :func:`_ruled_lines_from_layout`). A ``None`` layout (e.g. probed before page preparation) returns ``False`` — the caller should fall back to raster. F)rmr)r min_liness rlayout_has_ruled_linesrs"~ '/ 0I ==r)F)Nr((rr)r)r()&rr numpyr playa.minerrrrr_rr%r>r*r+r,r2rirzr_LINE_COALESCE_TOLrr}rrrrr _JOINT_TOLrrrrrrrr_VECTOR_ENGINE_MIN_LINESrrrrrs v #",GI+`  ;&|84B:%P(n  1#L-7`4F3l   (2$!!$(::D$NDN*BL (.F >r