WjFDdZddlZddlmZmZmZmZddlm Z m Z ddl m Z m Z mZdZddZdd Zdd Zdd ZdZdZe efdZdS)a1 Edge feature computation module Maintained by: PDF Engineers (edge_type implementations) + AI Researchers (orchestration) Purpose: Compute edge attributes for graph neural network input Edge types: - default: Relative bbox geometry (get_edge_transform_bbox) - SEO: Default + alignment features (get_edge_transform_bbox_add_alignment) - PRS: Presidio spatial features (compute_edge_features) - YF: Default + "what's between the two endpoints" features (get_edge_transform_yf) -- num_bbox_cross / num_vector_cross, how many other text bboxes / vector lines the straight line between the edge's two node centers passes through. Unlike SEO's alignment flags (redundant with the default 18-dim relation features and with DGCNN's own h_j-h_i difference-vector inductive bias), this is genuine page-level context that neither endpoint bbox alone, nor the two together, can express. To add a new edge type: 1. Implement compute function in this file 2. Register it in get_edge_attr() N)get_edge_by_directional_nnget_edge_by_alignmentget_edge_transform_bbox%get_edge_transform_bbox_add_alignment)get_rect_member_idfind_closed_border_rects)$extract_bbox_features_by_roi_poolingDEFAULT_FEATURE_MAP_POOLING_OPS DEFAULT_CLASS_LOGITS_POOLING_OPSc||z }||z } tj|jtj} tj|jtj} tj|jt } | ||z f|||z f| ||z f| ||z ffD]X\} }t | dkr | |dkz} "|| z }| dkrtj| |} Ctj| |} Y| | | kz} | S)a0 Liang-Barsky segment-vs-many-axis-aligned-rects intersection test, vectorized over rects for one fixed segment. Segment: (x0, y0) -> (x1, y1), scalars. Rects: rx1, ry1, rx2, ry2 -- each an (M,) array (parallel arrays of rectangle bounds to test against). Returns: (M,) bool array: whether the segment intersects each rect (full containment of either endpoint inside a rect also counts as an intersection -- no special-casing needed, Liang-Barsky handles it the same way as a proper crossing). dtypeg-q=r) npzerosshapefloat64onesboolabsmaximumminimum)x0y0x1y1rx1ry1rx2ry2dxdyt0t1validpqrs /Users/tedpeters/Documents/Projects/Claude Projects/TPC Houses/house-viewer/.venv/lib/python3.11/site-packages/pymupdf/layout/pymupdf_util_edge.py_segment_rect_intersect_maskr*"s bB bB #)2: . . .B "* - - -B GCIT * * *E#rCx2sRx.B3S/Bb>R ' '1 q66E>> a1f EEAA1uuZA&&ZA&& bBhE Lc &t||}t|}|dkr6tj|tjdtjgdStj|tj}|dddf|dddfzdz }|dddf|ddd fzdz }|dddf|dddf|dddf|ddd ff\}} } } t|} d} d&||d &|d }||\}}t|t|z}|rvtj d |Dtj d |Dtj d|Dtj d|Df} &t||&d}&r tj &fd|D}tj |tj}tj |tj}tj |tj}tj | t}t|D]\}\}}||||}}||||}}|}d||<d||<t#|||||| | | }tj||z||<| 4| \} }!}"}#t#||||| |!|"|#}$tj|$||<|#||dkr||||krd||<tjtj|tj||gdtj}%tj||%gdS)ae edge_type='YF': the default 18-dim relation features (get_edge_transform_bbox) plus 2 new columns that require knowing every OTHER element's position on the page -- genuinely non-local information that neither the 18-dim relation features nor DGCNN's own h_j-h_i difference-vector message construction can express, unlike SEO's alignment flags (see module docstring): num_bbox_cross: how many other text bboxes the straight line between the two endpoint centers passes through. num_vector_cross: how many vector lines (from data_dict['vector_lines'], the same cache used by pymupdf_util_yf.py's vector_margin_* channels) that line passes through. same_rect_member: 1.0 if both endpoints' centers fall inside the SAME fully-closed border rectangle (e.g. the same full-border table -- see pymupdf_util_base.find_closed_border_rects), else 0.0. This is what actually disambiguates "two cells of the same table" (should connect) from "two cells of separate, nearby tables" (should not) -- num_bbox_cross/num_vector_cross alone can't reliably tell these apart, since both situations can show small counts of each. Deliberately NOT based on page.cluster_drawings()-style proximity clustering -- see find_closed_border_rects's docstring for why. num_bbox_cross and num_vector_cross are log1p-compressed before being appended: raw counts range from 0 (short adjacent edges) to several dozen (edges spanning most of the page), and log1p keeps one large count from dominating. same_rect_member is already a clean binary flag. Assumes no bbox-fully-contains-another-bbox case among text elements (true for PDF-native text extraction: one parsed text line/word never encloses another). Liang-Barsky handles full containment the same as a proper crossing regardless, so this assumption affects interpretation ("crossing" vs "containing") but not correctness of the count. Args: bboxes: (N, 4) array/list of [x1, y1, x2, y2]. edge_index: list of (i, j) node-index tuples. data_dict: optional; if data_dict['vector_lines'] / ['closed_rects'] are present (see pymupdf_util_base.extract_base_elements), they're reused instead of being recomputed. If 'vector_lines' is present but 'closed_rects' isn't, it's computed here from the cached lines. If neither is present, num_vector_cross is 0 and same_rect_member is 0 for every edge (shape stays consistent; only get_edge_dim's dummy-data probing relies on this graceful fallback). Returns: (E, 21) array: 18 relation features + [log1p(num_bbox_cross), log1p(num_vector_cross), same_rect_member]. r)rrraxisNg@r- closed_rects vector_linescg|] }|j S)r.0r(s r) z)get_edge_transform_yf..444qad444r+cg|] }|j Sr4)rr5s r)r7z)get_edge_transform_yf..r8r+cg|] }|j Sr4)rr5s r)r7z)get_edge_transform_yf..r8r+cg|] }|j Sr4)rr5s r)r7z)get_edge_transform_yf..r8r+c0g|]}t|Sr4)r)r6br1s r)r7z)get_edge_transform_yf..s$UUUQ/<@@UUUr+Fg?)rlenr concatenateemptyfloat32asarrayrgetlistarrayr rrr enumeratecopyr* count_nonzerostacklog1pastype)'bboxes edge_index data_dictbaseE bboxes_arr centers_x centers_yall_x1all_y1all_x2all_y2N vec_rectsr2h_linesv_linesall_vecrect_idsnum_bbox_crossnum_vector_crosssame_rect_memberself_exclude_basee_idxijrrrrexcludehitvx1vy1vx2vy2vhitextrar1s' @r)get_edge_transform_yfrnGs j #6: 6 6D JAAvv~tRXfBJ%G%G%GHqQQQQF"*555JAAAqD!Jqqq!t$44;IAAAqD!Jqqq!t$44;I&0A&6 111a48H&0A&6 111a48H&J"FFFF JAIL }}^44  }}^44  #+ GW7mmd7mm3G H44G44455H44G44455H44G44455H44G44455  #7II HW8UUUU*UUUVVXarz222Nx444x444...":..** v11y|B1y|B#((**  *2r2r666SYZZ " 0w ? ?u  !* Cc3/BBS#sSSD&(&6t&<&< U #  HQK2$5$5(1+RS:T:T&) U # H . ! !28,<#=#=?OP     fRZ  >4-a 0 0 00r+c|dkrt||S|dkrt|||S|dkr9ddlm}|j\}}}t j|j} ||| ||St||S)uJ Compute edge attributes based on edge type. Args: bboxes: np.ndarray of shape (N, 4), float32 edge_index: list of (i, j) tuples edge_type: str — '', 'SEO', 'PRS', 'YF', etc. page_img: page image array (required for 'PRS') Returns: edge_attr: np.ndarray of shape (E, D) SEOYF)rOPRSr)compute_edge_features) node_bboxesrN page_width page_height) rrnpresidio.graphrtrrrFTr) rMrN edge_typerOpage_imgrtpage_hpage_w_ temp_edge_idxs r) get_edge_attrrsE4VZHHH d  $VZ9MMMM e  999999$N,,. $$M06FLLL L'vz:::r+ctjgdgdgtj}ddg}t||||}|jdS)z Get edge attribute dimension by computing on dummy data. Used for single-node edge case. Args: edge_type: str page_img: page image array (required for 'PRS') Returns: int: edge feature dimension )r$@r)4@r>@rr)rr)rr)r{r)rrFrBrr)rzr{ dummy_bboxesdummy_edge_index dummy_attrs r) get_edge_dimrsk8   ZL'|-=yS[\\\J  A r+4Dc|dkrFt|dd\}}t|d}tt||z}nt|dd\}}|S)z Build edge index from bboxes. Args: bboxes: np.ndarray of shape (N, 4) edge_sampling: '4D' (directional NN) or '4D+AL' (directional NN + alignment) Returns: edge_index: list of (i, j) tuples z4D+ALiPg333333?) vertical_gapr)dist_threshold)rrsortedset)rM edge_sampling edge_index1r~ edge_index2rNs r)build_edge_indexrst3FEPSTTT Q+F1EEE C k 9::;; 265sSSS A r+crg}|\}}t||D]\}}||}||}t|d|d} t|d|d} t|d|d} t|d|d} || | | | g|S)a Compute the union bbox of each edge's two endpoint node bboxes. NOTE: for image-edge features specifically, prefer compute_edge_gap_bboxes() instead -- see its docstring for why a plain union tends to just re-pool each node's own visual content rather than capturing what's actually between the two nodes. This function is kept as a general "bounding box of two boxes" utility. Args: edge_index: np.ndarray of shape (2, E) or any (row, col) pair of equal-length sequences of node indices. original_bboxes: list of [x1, y1, x2, y2], indexed by node. Returns: list of [x1, y1, x2, y2], one per edge. rrr0r-)zipminmaxappend) rNoriginal_bboxes edge_bboxesrowcol node_idx_1 node_idx_2bbox1bbox2rrx2y2s r)compute_edge_union_bboxesrs$KHC"%c3---- J + + q58 $ $ q58 $ $ q58 $ $ q58 $ $BB+,,,, r+c g}|\}}t||D]5\}}||\}}} } ||\} } } }| | kr| | }}n| |kr| |}}nd\}}| | kr| | }}n||kr||}}nd\}}|||||||gt|6||t|| |t| |g|6|t|| |t| | |g|t|| t|| t| | t| |g7|S)a= Compute the "corridor" rectangle between each edge's two endpoint node bboxes -- the space between them, excluding both nodes' own areas -- rather than the union (which mostly just re-covers each node's own content for adjacent neighbors, diluting whatever visual signal actually sits in the gap: a ruling line, whitespace, another element). For two boxes A, B: - On the axis where they're separated (no overlap), the gap uses the actual space BETWEEN them on that axis (excludes both boxes). - On the perpendicular axis, the gap uses the INTERSECTION of A and B's extents on that axis (only the band both boxes actually occupy), not the union (which would include the part of one box that has no counterpart in the other). - If A and B are separated on BOTH axes (diagonal neighbors), the gap is the small rectangle between their facing corners. - If A and B overlap (no separating axis on either side -- rare for PDF-parser-derived text bboxes, but possible e.g. when a chart or image bbox contains a text bbox), there's no meaningful "between" region, so this falls back to the union -- an intersection here would lose the very context (the smaller box) that an edge to it is meant to capture. Args: edge_index: np.ndarray of shape (2, E) or any (row, col) pair of equal-length sequences of node indices. original_bboxes: list of [x1, y1, x2, y2], indexed by node. Returns: list of [x1, y1, x2, y2], one per edge. )NN)rrrr)rNrrrrrrax1ay1ax2ay2bx1by1bx2by2gx0gx1gy0gy1s r)compute_edge_gap_bboxesr$s@KHC"%c3--!]!] J,Z8S#s,Z8S#s #::CCC CZZCCC!HC #::CCC CZZCCC!HC ?s   S#s3 4 4 4 4 _   Sc]]CS#G H H H H _   C sCSMM3G H H H H   C s3}}c#smmSQTVY]][ \ \ \ \ r+c t||} t|| |||} t|| |||d} tj| | gd} tj|| gdS)a Append ROI-pooled image features to edge attributes. Pools feature_map (decoder embedding) and class_logits (per-class scores) SEPARATELY, using the same scheme as node-level image features (see BoxRFDGNN.get_nn_input_from_datadict), then concatenates both onto edge_attr. class_logits is always softmaxed before pooling since its entropy/margin ops are only meaningful over a probability distribution. This is a standalone, single-shot entry point: it builds its own softmax/SAT tables via extract_bbox_features_by_roi_pooling() every call. If you are ALSO pooling the same feature_map/class_logits for node bboxes in the same request (as BoxRFDGNN does), prefer building a RoiPoolingSession per tensor and calling .query() for both node and edge bboxes instead -- that shares the bbox-independent softmax/SAT setup between the two queries rather than rebuilding it here. See roi_pooling.RoiPoolingSession and BoxRFDGNN.get_nn_input_from_datadict. Args: edge_attr: existing edge attributes, shape (E, D) edge_index: np.ndarray of shape (2, E) original_bboxes: list of [x1, y1, x2, y2] feature_map: decoder embedding output, shape (1, 5*F, H, W) class_logits: per-class segmentation logits, shape (1, C, H, W) page_w, page_h: page dimensions feature_map_pooling_ops: pooling_ops applied to feature_map class_logits_pooling_ops: pooling_ops applied to class_logits Returns: edge_attr: np.ndarray of shape (E, D + D_img) ) pooling_opsT)r apply_softmaxrr.)rr rr@) edge_attrrNr feature_map class_logitsr}r|feature_map_pooling_opsclass_logits_pooling_opsr feat_pooled logit_poolededge_image_featuress r)append_image_edge_featuresrlsF**oFFK6[&&+K8k66,L .+|)D1MMM >9&9: C C CCr+)N)roNN)roN)r)__doc__numpyr common_utilrrrrpymupdf_util_baserr roi_poolingr r r r*rnrrrrrrr4r+r)rsc.ZZZZZZZZZZZZKKKKKKKK<<<<<<<<<< """Jt1t1t1t1n;;;;<*(>EEET9X9Y/D/D/D/D/D/Dr+