j9ddlZddlZddlZddlmZddlmZmZm Z m Z dPdej de dej fdZ dej dej fdZd ZdQd ej d e d edeeee e feeeee e ffffdZdRd ej d ededeee e ffdZdej de dej fdZdej defdZdej defdZdSdZdZde dej fdZdej de de fdZdej de d e ddfd!Zde d"ej d#ej fd$Zd%ej d&ej d'ej deeed(ee dee f d)Z dTd,ej dee eeeefd-e d.e d/e d0e!d1e!d2e!dej fd3Z"d4ej d5edej fd6Z#d4ej dej fd7Z$d8Z%dUd;Z&d<Z' dVd=ej d>eed?eedzd@e dAe deef dBZ(dCej dDe dEe dej fdFZ)dGej dHe deefdIZ* dWd=ej d>eed?eedzd@e dKe deef dLZ+e,dMkre-edNdOdSdS)XN)Counter)OptionalListDictTuplexaxisreturnc|tj||dz }tj|}|tj||dz S)z Numerically stable softmax along the given axis. Args: x: input array of any shape. axis: axis along which softmax is computed. Returns: np.ndarray of the same shape as x, summing to 1.0 along axis. Tr keepdims)npmaxexpsum)rr x_shiftedexp_xs /Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/pymupdf/layout/common_util.py softmax_numpyr sJBF14$7777I F9  E 26%dT::: ::c8ddtj| zz S)z Numerically stable sigmoid. Args: x: input array of any shape. Returns: np.ndarray of the same shape as x, values in (0, 1). g?)rrrs r sigmoid_numpyrs #r " ##rc |s tjdtjStj|tj}|ddddgf}|ddddgf}|ddddgf|z }|ddddgf|z }tj|d}tj|d}|ddddgf|z |z |ddddgf<|ddddgf|z |z |ddddgf<|}|dddf|dddfz }|dddf|dddfz }|dddf|dddfzdz } |dddf|dddfzdz } tj|dddf|dddf|dddf|dddf| | ||fd } | S) a Normalizes bounding box coordinates (x1, y1, x2, y2) and calculates center coordinates and dimensions. Args: bboxes_list (list of list): A list of bounding boxes, e.g., [[x1, y1, x2, y2], ...]. It is assumed that the coordinates are in the format (top-left, bottom-right). Returns: numpy.ndarray: A NumPy array where each row contains the normalized (x1, y1, x2, y2), center coordinates (ctr_x, ctr_y), width (box_w), and height (box_h). Shape: [num_boxes, 8] )rdtypeNrư>r )remptyfloat32arrayminrmaximumstack) bboxes_list bbox_datamin_xmin_y cell_box_w cell_box_hboxesbox_wbox_hctr_xctr_y boxes_feats rget_boxes_transformr5&s`" 2xbj1111BJ777I aaa!Qi $ $ & &E aaa!Qi $ $ & &E111q!f9%))++e3J111q!f9%))++e3JJ--JJ--J&aaa!Qi058JFIaaa!Qi%aaa!Qi058JFIaaa!Qi E !!!Q$K%1+ %E !!!Q$K%1+ %E 111a4[5A; &! +E 111a4[5A; &! +E5A;aaad U111a4[%1+ %7=>@@@J r333333?bboxdist_threshold vertical_gapc &t|&tj&t}|dddf|dddfzdz }|dddf|dddfzdz }|dddf|dddfz }tj|&&dfj|dddf||zz &&dfk|&&dfj|dddf||zz&&dfk}tj|&&dfj|dddf&&dfk|&&dfj|dddf&&dfk}|dddf&&dfj|dddf&&dfz dz} |dddf&&dfj|dddf&&dfz dz} |dddf&&dfj|dddf&&dfz dz} |dddf&&dfj|dddf&&dfz dz} d} | | | z|||dddf&&dfj|dddf&&dfk}| | | z|||dddf&&dfj|dddf&&dfk}| | | z||dddf&&dfj|dddf&&dfk}| | | z||dddf&&dfj|dddf&&dfk}tj| }tj||dddf&&dfj|dddf&&dfk}tj||}tj ||<d&fd }i}||d }||d <||d }||d<||d}||d<||d}||d<||d}||d<tj|}tj|}t&D]}tj ||tj kr)tj ||tj ||f<tj ||tj kr)tj ||tj ||f<||d}||d<||d} | |d<g}!|D]}"|!|"t!t#d|!D}#fd|#D}$t%|$d}%|$|fS)a NOTE (direction-label fix): this function's internal direction names used to be swapped -- what was called 'left_dis_matrix' actually finds each box's nearest neighbor to its RIGHT, 'right_dis_matrix' actually finds the neighbor to its LEFT, 'up_dis_matrix' actually finds the neighbor BELOW, and 'down_dis_matrix' actually finds the neighbor ABOVE (verified empirically: e.g. for 3 boxes in a row, the matrix named "left" matched each box to the one on its right). All of the variable names and direction_edges dict keys below have been corrected to match what is actually computed. The underlying distance formulas and filter conditions are UNCHANGED from before this fix, so the final `edge_index` returned by this function (the only thing build_edge_index actually uses -- it discards direction_edges) is bit-for-bit identical to before. This matters for reproducibility with any model already trained on graphs built by the previous version of this function. Only the *direction_edges* dict (previously unused by any caller in this codebase) is affected in practice: code that starts relying on direction_edges['left'] meaning "genuinely left of this node" would have silently gotten right-neighbors before this fix. Open question, NOT resolved here (see down_neighbor_y_dis_matrix below): the y-only-distance matrix historically named 'down_y' reused what was then called 'up_dis_matrix's filter condition. Since that matrix's TRUE behavior is "find the neighbor below", down_y ends up being a y-distance-only variant that's largely redundant with the (corrected) down_neighbor_dis_matrix, just with an added x-alignment constraint and coarser (y-only, not x+y) ranking. Whether this was an intentional distinct signal or a copy-paste of the wrong direction's filter is unconfirmed -- flagged for future review rather than changed, since its actual behavior (like everything else here) is left untouched by this fix. rNrr rrctj|}g}t|D]Q\}}||||tj|jdt R|s"tj|jdt }ntj|}tj ||<|S)NFr) rcopy enumerateappendfullshapebool logical_orreducemathinf)base_distance_matrix conditionsfiltered_matrixall_conditionsicond filter_masks rget_filtered_distance_matrixz@get_edge_by_directional_nn..get_filtered_distance_matrixs'"677 ,, ^ ^GAt%%d++++%%bg.B.H%W[&\&\&\]]]] ?'"6">K'+x $rUnnamedctj|d}tj|d|tjkfdt D}|S)Nrr"chg|].}| t|t|f/S)int).0rK min_indices valid_masks r zKget_edge_by_directional_nn..get_nearest_indices..s:[[[QZXY][CFFC A//0[[[r)rr&argminrErFrange)distance_matrix matrix_name min_distancesindicesrUrVbbox_nums @@rget_nearest_indicesz7get_edge_by_directional_nn..get_nearest_indicess`Q777 ia888 "dh. [[[[[%//[[[rleft_neighbor_dis_matrixleftright_neighbor_dis_matrixrightup_neighbor_dis_matrixupdown_neighbor_dis_matrixdowndown_neighbor_y_dis_matrixdown_ysecond_down_neighbor_dis_matrix second_downsecond_up_neighbor_dis_matrix second_upcJg|] }t|t|f!SrR)r&r)rTitems rrWz.get_edge_by_directional_nn..s) > > >c$iiT # > > >rcXg|]&}t|d|dz k$|'Srr)abs)rTror8s rrWz.get_edge_by_directional_nn..s?DGd1g4E0F0F0W0W0W0W0Wrc"|d|dfS)NrrrRrs rz,get_edge_by_directional_nn..sAaD!A$<r)key)rO)lenreyerBrCrepeatreshapeTr=rErFrYr&rXvaluesextendlistsetsorted)'r7r8r9 eye_matrix center_y_box center_x_box bbox_height y_center_flag x_center_flaghor_x_dis_matrixhor_y_dis_matrixver_x_dis_matrixver_y_dis_matrixrNrbr`rfrdrh!_down_neighbor_y_filter_conditiondown_neighbor_y_filter_maskr_direction_edges left_edges right_edgesup_edges down_edges down_y_edgesdown_neighbor_dis_matrix_copyup_neighbor_dis_matrix_copyrKsecond_down_edgessecond_up_edges all_raw_edgesedgesori_edge_index_listfinal_edge_listfinal_edge_list_sortedr^s' ` @rget_edge_by_directional_nnrfs D4yyH---JAJaaad+q0LAJaaad+q0Lqqq!t*tAAAqDz)KMH%%--xn==?41:P[^jPjCjBrBr CCgxn-- .H%%--xn==?41:P[^jPjCjBrBr CCgxn-- .MMH%%--xn==?$qqq!t*BSBST\B]B]BeBegoqsftBuBuuH%%--xn==?$qqq!t*BSBST\B]B]BeBegoqsftBuBuuM QQQT ))(33;;XrNKKMPTUVUVUVXYUYPZPaPabjPkPkPsPs 2QQQQQT ))(33;;XrNKKMPTUVUVUVXYUYPZPaPabjPkPkPsPs 2QQQQQT ))(33;;XrNKKMPTUVUVUVXYUYPZPaPabjPkPkPsPs 2QQQQQT ))(33;;XrNKKMPTUVUVUVXYUYPZPaPabjPkPkPsPs 2QQ(!= <++ QQQT (##++XrN;;=aaadARARS[A\A\AdAdfnpresAtAtt !! <;++ QQQT (##++XrN;;=aaadARARS[A\A\AdAdfnpresAtAtt    <;++ QQQT (##++XrN;;=aaadARARS[A\A\AdAdfnpresAtAtt   :9++ QQQT (##++XrN;;=aaadARARS[A\A\AdAdfnpresAtAtt"$)9!:!:(*  QQQT (##++XrN;;=aaadARARS[A\A\AdAdfnpresAtAtt))% #%-0QS`"a"a>Bh:;O$$%=?YZZJ(OF%%&?A\]]K*OG""#9;STTH$OD$$%=?YZZJ(OF&&'AC_``L ,OH%'G,D$E$E!"$'*@"A"A8__aa 6/2 3 3tx ? ?\`\d )!RY7TUV7W-X-X*X Y 6-a0 1 1TX = =X\X` '295PQR5S+T+T(T U++,IKlmm%6OM"))*EGfggO#2OK M ''))$$U#### > > > > >??,O$O9O9OPPP O ++rMbP?' center_limitc t|}|dkrgS|dddf}|dddf}|dddf}|dddf}||zdz }||zdz } tj|dddf|dddfz dz| dddf| dddfz dzz} tj||ft} |||fD]4} | tj| dddf| dddfz |kz} 5tj||ft} ||| fD]4}| tj|dddf|dddfz |kz} 5| |k| | zz}tj|d}tj|\}}tt| | S)aj Vectorized (broadcasting-based, matching get_edge_by_directional_nn's style). Previously a pure-Python O(N^2) double loop with a per-pair `any(...)` generator call -- the only unvectorized edge-construction function in this module. Not currently used by build_edge_index's default '4D' path (only by the experimental '4D+AL' path, not currently active), but fixed for consistency and to remove the latent bottleneck. Returns the exact same edge set, in the exact same order, as the previous implementation (both iterate implicitly in row-major (i, j) order over i < j pairs). rNrrr rk) rvrsqrtzerosrBrrtriunonzeror}ziptolist)r7r8rr^leftstopsrightsbottoms centers_x centers_y center_dist hor_alignedh ver_alignedvvalidi_idxj_idxs rget_edge_by_alignmentr"s4yyH!|| AJE 1:D !!!Q$ZF111a4jG1$I1$I' 111d7 iaaa0 0Q6 QQQW  $' 2 2q 8 9K (Hh/t<<rrrr) rvrr#r$r%rr'r(r?rrrastyper)rrrrrdeltarrrrrrrrrrrris_left_alignedis_center_alignedis_right_alignedis_top_alignedis_middle_alignedis_bottom_alignedrs r%get_edge_transform_bbox_add_alignmentrsx :!xrz2222HZ((M }QQQT"#A}QQQT"#A E 111a41QQQT7 B 111a41QQQT7 B 111a41QQQT7 B 111a41QQQT7 B :a1gqAw ' 'D :a1gqAw ' 'D :a1gqAw ' 'D :a1gqAw ' 'D $dD)222A 111a41QQQT7 B 111a41QQQT7 BH OOQqqq!tWqAw&2:6777 OO 111a41QQQT7 rEz* OOQqqq!tWqAw&2:6777 OO 111a41QQQT7 rEz* OOBF2e,--... OOBF2e,--... OO 111a41QQQT7 rEz* OO 111a41QQQT7 rEz* OO 111a41QQQT7 rEz* OO 111a41QQQT7 rEz* OOBF2e,--... OOBF2e,--... OO 111a41QQQT7 rEz* OO 111a41QQQT7 rEz* OO 111a41QQQT7 rEz* OO 111a41QQQT7 rEz* OOBF2e,--... OOBF2e,--...va1g!!!Q$/00D8@@LLO111a41QQQT7!2a 71QQQT7Qqqq!tW;LPQ:Q QRRVZZbbcecmnnqAw111a4011T9AA"*MMfQqqq!tWqAw.//47?? KKN111a41QQQT7!2a 71QQQT7Qqqq!tW;LPQ:Q QRRVZZbbcecmnn!!!Q$!AAAqD' 122d:BB2:NN OOO$$$ OO%&&& OO$%%% OON### OO%&&& OO%&&&***I iSTJJJI rTcZd}gd}|d}|D]_}||vr||z } |r|dz }&|r|dz }@|s|dz }Z|dz }`d}d}d} t|D]8\} }| d kr||z }n%||kr| dz } |t | z }||z }d} |}9|dkr|t | z }|}|rSg} |D]}|r#| t |9|dkr| d U|dkr| d q|dkr| d |dkr| d ||vr,| d||ztd|d| D} dg|z} d }| D]K}|D]1}t |dz | |<|dz }|t| krn2|t| krnL| S|S)N()u•-*+<>()u→u✓#u□u■u‣u◦u▪.:u※rWDrCrr zInvalid pattern character: c.g|]}t|dS)02o)format)rTrs rrWz$get_text_pattern..ns"4446!U##444rrr) isspaceisdigitisalnumr>strr?rSindex Exceptionrv)text text_pattern return_vectormax_lensymbolspatternccompressed_patternprev_c prev_repeatc_idxvectorencodedencoded_vectorcur_idxcodes rget_text_patternr9sGDDDG  AG||1  3 3YY[[ 33 !'**  HE1zz"a'""Q;;1$K&#k*:*::&&!+&"#KFF R<< #k"2"2 2 )  C CAyy{{ C c!ff%%%%c b!!!!c b!!!!c b!!!!c b!!!!g b7==#3#334444 Aa A ABBB44V444  D  *-a&&1*w'1 c.1111E2#n----.rctj||ftj}|\}}tt |D],}t |||||||<-|S)uq edge_index와 edge_label을 사용하여 n x n 근접이웃 행렬을 반환합니다. Args: edge_index: 연결의 인덱스를 나타내는 2D 리스트. edge_label: 연결 레이블을 나타내는 1D 리스트. 1은 연결이 있음을, 0은 연결이 없음을 의미합니다. Returns: n x n 근접이웃 행렬 (numpy array). r)rrrrYrvrS)num_noder edge_label adj_matrixrowcolrKs rget_edge_matrixr&}so8X.bh???JHC 3s88__88%(A%7%7 3q63q6"" r num_nodescBtj|tjS)zCInitialize Union-Find parent array where each node is its own root.r)raranger)r's r_make_union_findr*s 9Ybh / / //rparentch|||kr%|||||<||}|||k%|S)z Find root with path compression.rR)r+rs r_findr-s@ )q..6!9%q 1I )q.. Hryc`t||t||}}||kr|||<dSdS)z&Union two sets by linking their roots.N)r-)r+rr.rxrys r_unionr2s< 61  uVQ//B Rxxr xrrowscolsct|}t||D]\}}t|||i}t j|tj}t|D]3}t||} | |vrt||| <|| ||<4|t|fS)z Find connected components via Union-Find. Returns: labels : (N,) array where labels[i] is the component id of node i n_components : total number of components r) r*rrr2rr#rrYr-rv) r'r3r4r+rr. root_to_complabelsrKroots rgraph_connected_componentsr9si ( (FDKKMM4;;==111vq!L Xirx 0 0 0F 9  ''VQ | # #!$\!2!2L  &q 3|$$ $$rnode_cls node_score edge_matrixlabel_priority_listct|}t||kst||krtdtj|tj}tj|dt}tj|\}} t||| \} } |dkr$t| dznd} t| t|dz} tj | tj }t|D]\}}|| kr|||<g}t| D]}d}| |k}tj|d}||}tj|t| dz}| }tj||kd}t|dkrt|d}n3||}|tj|}t|}|}t|dkrgd }n||}t'|d d df}t'|d d df} t'|d d d f }!t'|d d d f }"|| |!|"g}|||||d |S)a} Drop-in replacement for the NetworkX-based implementation using pure numpy. No scipy dependency ? connected components are found via Union-Find. Optimizations over the original: 1. O(N^2) double for loop -> np.triu + np.where (vectorized edge extraction) 2. NetworkX connected_components -> Union-Find (no external dependency) 3. bbox min/max -> np.min/max on masked array slice (vectorized) 4. majority vote + priority tie-break -> np.bincount + priority lookup array 5. tie_class reset per group (bug fix from original) Args / Returns: identical to the original function. zLbboxes and node_score must have the same length as node_cls and edge_matrix.rrrr) fill_valuer;) minlength)rrrrNrr )indicies group_class group_bbox tie_class)rv ValueErrorrr%r$rrrBrr9rSrr@rFr>rYrbincountrXfloatr&r?)#r:r;r<rr=r' bboxes_arrupperr3r4r7 n_componentsmax_cls lookup_sizepriority_lookupprioritycls_idgroupscomp_idrDmaskr]comp_clscounts max_counttiedrBtied_prioritiesbestrC comp_bboxesx1y1x2y2s# rgroup_node_by_edger^s.(H I 6{{i3z??i#?#?ghhh& 333J GK1 % % % , ,T 2 2E%JD$ 6itLLFL*3Qc(,,..!!A%%AGgs#677!;<XX\\^^1D1Dq1HIIIJJLL x)+,,Q/ t99>>d1g,,KK.d3O /223Dd))K#I w<<1  ---JJ$T*K{111a4(,,..//B{111a4(,,..//B{111a4(,,..//B{111a4(,,..//Bb"b)J &$"        MrrFr page_width page_heightroi_align_output_size apply_softmaxconcat_mean_maxadd_uncertaintyc|jdksJd|j|j\}} } } |dks Jd|d} |} | dks Jd|r}| | d}||dd z }t j|| |dd d z}||z | | | }|}n|| }| | d}||dd z }t j|| |dd d z}||z | | | }|r| d zn| }||rd ndz}t jt||ftj }dtj dtdtdtj fd}t|D]\}\}}}}| t|z }| t|z }||z||z} }||z||z}"}!|!|z }#|"| z }$|#| z }%|$| z }&g}'t| D]A}(| |(dz|&zz})t| D]$}*||*dz|%zz}+|'|+|)f%B|'sg},g}-|'D]K\}.}/|||.|/}0|,|0|r"|||.|/}1|-|1Lt j|,d}2|2d}3|r/|2d}4t j|3|4gd}5n|3}5|rt j|-d}6d }7|6t j|6|7zzd }8|8}9|6j\}:};t j|6dddd}|>}?t j|5t j|9|?gtj gd}5|5tj ||d|5jdf<|S)aI Extract per-bbox features with RoIAlign-like sampling and mean/max pooling, and uncertainty metrics. This version uses bilinear interpolation for more accurate feature extraction. Args: features (np.ndarray): Feature map tensor (N, C, H, W). Typically N=1. bboxes (List[Tuple[float, float, float, float]]): Boxes (x1, y1, x2, y2) defined on the same coordinate system as page_width/page_height. page_width (int): Width of the image used to produce 'features'. page_height (int): Height of the image used to produce 'features'. roi_align_output_size (int): The target height and width (P) for the sampled feature map (P x P). Default is 7. apply_softmax (bool): If True, apply channel-wise softmax per spatial location. concat_mean_max (bool): If True, output [mean; max] -> 2C dims; else only mean -> C dims. add_uncertainty (bool): If True, append entropy_mean and margin_mean -> +2 dims. Returns: np.ndarray: Shape (len(bboxes), C or 2C plus optional +2 for uncertainty). z features must be (N,C,H,W), got rzOnly batch size 1 is supported.rz1roi_align_output_size must be a positive integer.r;Tr )outg-q=rr feature_maprr.r cb|j\}}}tj|d|dz dz }tj|d|dz dz }ttj|ttj|}}|dz|dz} }||z } ||z } tj|d|dz }tj| d|dz } |dd||f} |dd||f} |dd| |f}|dd| |f}| d| z zd| z z| | zd| z zz|d| z z| zz|| z| zz}|S)z Perform bilinear interpolation on the feature map at fractional coordinates (x, y). The feature map is (C, H, W). Coordinates are 0-indexed, ranging from 0 to W-1 or H-1. rrr!N)rArcliprSfloor)rhrr.C_fH_fW_fx0y0rZr[dxdyf00f10f01f11 interp_vals rbilinear_interpolatez@extract_bbox_features_by_roi_align..bilinear_interpolate\s{ $) S# GAq#'D. ) ) GAq#'D. ) )RXa[[!!3rx{{#3#3BaaBV VWRC!G $ $ WRC!G $ $!!!R)$!!!R)$!!!R)$!!!R)$q2v!b&)bAF#$q2v#$b2   r?r"N)ndimrAryrrrrrrvr$ndarrayrGr>rYr?r(mean concatenater argpartitiontake_along_axissortr%r)@rrr_r`rarbrcrdNrHrfmapPfdenomprobs fmap_usedgdenom_gbase_dimout_dimrgrxrKrZr[r\r]scale_xscale_yfx1fy1fx2fy2 roi_width roi_height bin_size_x bin_size_y sample_pointsp_yy_centerp_xx_centersampled_features sampled_probssxsy interp_feat interp_prob patch_featmean_vecmax_vecpooled patch_probeps ent_map_flat entropy_meanC_ num_samplesidx_parttop_twomargins margin_means@ r"extract_bbox_features_by_roi_alignrs0> =A   R(.RR   JAq!Q 6664666 A;D A 666F666/ LLB   1t,, , qa1t,,u4U##Aq!,,  LLB   1t,, , qa%%Q%..6W%%aA..(.q1uuQH5!!A6G (CKK) < < >>rssCH(XAFFFG LLaL aj71:-G!,,..K^VRX|[6QY[Yc-d-d-d$elmnnnF#)==#<#<A Q   Jrimagenew_sizec|jdd\}}|\}}tj|dz||z zdz }tj|dz||z zdz }tj|t }tj|t } tj|dzd|dz } tj| dzd|dz } ||z dddf} || z dddf} tj|d|dz }tj| d|dz } |jdkry|| dddf|dddff}|| dddf| dddff}|| dddf|dddff}|| dddf| dddff}nl|tj| |}|tj| | }|tj| |}|tj| | }d| z d| z z}| d| z z}d| z | z}| | z}|jdkr/|d|z|d|zz|d|zz|d|zzn||z||zz||zz||zz}tj|dd|j S) aS Resize an image using bilinear interpolation with numpy (vectorized). Equivalent to cv2.resize(..., INTER_LINEAR). Parameters ---------- image : np.ndarray Input image (H, W) or (H, W, C). new_size : tuple (new_width, new_height) Returns ------- np.ndarray Resized image. Nrryrrr ).N) rArr)rkrrSrjr{ix_r)rrrwnew_wnew_hrr.rorprZr[rqrrIaIbIcIdwawbwcwdrgs r resize_imagers" ;rr?DAqLE5 5  C AI.4A 5  C AI.4A !  C B !  C B aAE " "B aAE " "B b&$' B b&!!!T' B QA  B QA  B zQ 2aaag;47 + , 2aaag;47 + , 2aaag;47 + , 2aaag;47 + , 26"b>> " 26"b>> " 26"b>> " 26"b>> " b&QV B q2vB b&BB bB8=zQ i=2 9  2 2 i=2   "9  2 3 3 b27 R"W $rBw . 733   & &u{ 3 33rc|jdks|jddkrtd|dddddftj}|dddddftj}|dddddftj}d|zd|zzd |zz}t j|dd tjS) a0 Convert a BGR image to grayscale using numpy only. Equivalent to cv2.cvtColor(image, cv2.COLOR_BGR2GRAY). Parameters ---------- image : np.ndarray Input image in BGR format, shape (H, W, 3). Returns ------- np.ndarray Grayscale image, shape (H, W). r rz/Input must be a BGR image with shape (H, W, 3).Nrrgv/?gbX9?gA`"?r)r{rArErrr$rjuint8)rBGrgrays rto_grayrs zQ%+a.A--JKKK aaaAgbj))A aaaAgbj))A aaaAgbj))A 19uqy 519 ,D 74C ' ' 1 11rct|d|d}t|d|d}t|d|d}t|d|d}td||z }td||z }||z}|d|dz |d|dz z} |d|dz |d|dz z} | | z|z } | dkr|| z ndS)Nrrrr )rr&) box1box2xi1yi1xi2yi2 inter_width inter_height inter_area box1_area box2_area union_areas r compute_iour1s d1gtAw  C d1gtAw  C d1gtAw  C d1gtAw  Cas##Kq#)$$L|+Ja47"tAwa'89Ia47"tAwa'89IY&3J&01nn: " "!;rrrc ddl}|dvrtd||||j\}}}}g}t d|D]}t |||jf} | |kr%t |||jf} t |||jf} t |||j f} t |||j f} | || | | | z| | zf| d|S)ag Find connected components in a binary mask and return their bounding boxes. Replaces the previous two-step pipeline: segmentation_connected_components() (Python BFS) _get_bboxes_from_labeled_image() (np.argwhere per label) Both steps are now handled by cv2.connectedComponentsWithStats in a single C++ call, which is ~100x faster than the Python BFS and eliminates the O(N * num_labels) argwhere scans. Args: binary_mask (np.ndarray): 2D uint8 array with 0 (background) and 1 (foreground). connectivity (int): 4 or 8. min_area_threshold (int): Components smaller than this pixel count are ignored. Returns: list[dict]: Each dict has keys 'label', 'bbox' (min_row, min_col, max_row, max_col), and 'area'. Same schema as the old _get_bboxes_from_labeled_image(). rN)rfrzconnectivity must be 4 or 8.) connectivityltyper)labelr7area) cv2rEconnectedComponentsWithStatsCV_32SrYrS CC_STAT_AREA CC_STAT_LEFT CC_STAT_TOP CC_STAT_WIDTHCC_STAT_HEIGHTr?) binary_maskrmin_area_thresholdr num_labels_statsregionslabel_idrrr.widthheights r!_find_connected_component_regionsrAsK*JJJ6!!7888!>>,cj?J5! G!Z((  53#33455 $ $ $ U8S%55677U8S_4566U8S%66788U8S%77899 1v:q5y1      Nrcddl}|dkr|S|dzdkrtd||j||f}|||j||jdS)as Performs binary opening (erosion followed by dilation) on a 2D binary image using a square kernel of ones. Args: binary_image (np.ndarray): A 2D uint8 array (H, W) with 0s and 1s. kernel_size (int): Side length of the square kernel. Must be an odd number. Returns: np.ndarray: The opened binary image (same dtype as input). rNrrz?Kernel size for morphological operations must be an odd number.) borderType borderValue)rrEgetStructuringElement MORPH_RECT morphologyEx MORPH_OPENBORDER_CONSTANT) binary_image kernel_sizerkernels r_binary_opening_numpyrusJJJaQ!Z[[[  & & k2F   L#.&SM`no  p ppr seg_logits class_names target_classmin_component_areamorphology_kernel_sizec t|}|jd|ksJd|jdd|d|d}|"tjd|tj}nEdt |Dtjfd |Dtj}tj|d }g} |D]} || ktj } |dkrt| |} t| d | } || } | D]}|d \}}}}|||||f}tj || k}|j r ||j z nd}| t|t|t|t|g| t!|d| S)a/ Extract bounding boxes only for the classes you care about. Args: seg_logits (np.ndarray): Per-class segmentation logits, shape (1, len(class_names), H, W). The caller must slice out exactly the class channels before calling this function; no implicit channel slicing happens here. Detection uses argmax, which is invariant to whether the values are raw logits or post-softmax probabilities, so either can be passed in. class_names (list[str]): Ordered list of class names (index i corresponds to channel i). target_class (list[str] | None): If given, only these classes are processed. None means process every class except background (class-id 0). min_component_area (int): Connected components smaller than this many pixels are ignored. morphology_kernel_size (int): Size of the square morphological opening kernel (must be odd). 0 or 1 disables opening. Returns: list[dict]: [{'bbox': [x1, y1, x2, y2], 'class': , 'score': }, ...] (x1,y1) is top-left, (x2,y2) is bottom-right in image coordinates. score = (# pixels of predicted class inside bbox) / (bbox area). rseg_logits channel count () must equal len(class_names) (O); caller must pass only the class-logit channels, not a larger feature tensor.rNrci|]\}}|| SrRrRrTidxnames r z4extract_bboxes_from_segmentation..HHHICdCHHHrc(g|]}|v|SrRrRrTn name_to_ids rrWz4extract_bboxes_from_segmentation..s"VVVa:ooz!}ooorr"r)rrr7rr7classscore)rvrArr)intpr>r%argmaxrrrr count_nonzerosizer?rSrG)rrrrr n_classesseg_maps active_ids class_mapresultclass_idrRrcls_nameregmin_rowmin_colmax_rowmax_colroipix_clsrr s @r extract_bboxes_from_segmentationr"s,FK  I  A ) + + + >Z%5a%8 > >& > > > , + + !}HYq)27;;; HH;1G1GHHH XVVVVlVVV$&G---  (+++IFX%--bh77 "A % %(/EFFD4 1    x(  C14V .GWgwGGOWW_<=C&sh77G*-(;Gch&&E MMWs7||S\\3w<<P!u      Mrrtarget_htarget_wc(|j\}}tj||z|z tj}tj||z|z tj}|tj||S)am Resize a 2-D integer label map using nearest-neighbor interpolation. Pure numpy; no scipy/cv2 dependency. Args: class_map (np.ndarray): (H, W) integer array of class IDs. target_h (int): Output height. target_w (int): Output width. Returns: np.ndarray: (target_h, target_w) integer array, same dtype as input. )rArr)rrr)rr#r$src_hsrc_wrow_idxcol_idxs r_resize_class_map_nearestr*sz?LE5y""U*X5==bgFFGy""U*X5==bgFFG RVGW-- ..rrmin_areac|j\}}tj||ft}g}tj|\}}gd}t ||D]\} } || | fr| | fg} d|| | f<| x} } | x}}d}d}|t| kr| |\}}|dz }|dz }|| kr|} || kr|} ||kr|}||kr|}|D]a\}}||z||z}}d|cxkr|krEnd|cxkr|kr5n/|||fs(|||frd|||f<| ||fb|t| k||kr"|| || dz|dzf|d|S)a BFS-based connected-component labeling on a 2-D binary uint8 mask. 8-connectivity. Pure numpy + Python; no cv2/scipy. Args: binary_mask (np.ndarray): (H, W) uint8 array, 0 = background, 1 = foreground. min_area (int): Components with fewer pixels than this are discarded. Returns: list[dict]: Each entry has 'bbox' (min_row, min_col, max_row, max_col) and 'area' (pixel count). r))r;r;)r;r)r;r)rr;)rr)rr;rq)rrTrr)r7r) rArrrBrrrrvr?)rr+rrvisitedrfg_rowsfg_colsoffsetsstart_rstart_cqueuemin_rmax_rmin_cmax_crheadrrdrdcnrncs r _find_connected_components_numpyr>s1  DAqh1vT***GGz+..GW(((G  0 0'..2B2BCC   7G# $  7#$$( !SZZ;DAq AID AID5yy!%5yy!%5yy!%5yy!%! + +BRRB;;;;Q;;;;;1;;;;Q;;;;;wr2v;;WY[]W]K^;&*GBFOLL"b***SZZ 8   NNuqy%!)<    Nrddownscale_sizec $t|}|jd|ksJd|jdd|d|d}|jd|jd}}tj|d} |t ||z } t dt t || z} t dt t || z} t| | | } | | z||zz }t dt tj||z}|| z }|| z }|"tj d|tj }nEd t|D$tj $fd |Dtj }g}|D]K}| |k tj}t|| }||}|D]}|d \}}}}t ||z}t ||z}t!|t tj||z}t!|t tj||z} | |||| f}!t tj|!|k}"|!jr |"|!jz nd}#|||| |g|t)|#d M|S)a Numpy-only equivalent of extract_bboxes_from_segmentation(). To compensate for the slower Python BFS, detection is performed on a downscaled class map (longest side capped at `downscale_size`), and the resulting bounding boxes are scaled back to original resolution. Morphological opening is omitted; callers should apply post-processing if needed. Args: seg_logits (np.ndarray): Per-class segmentation logits, shape (1, len(class_names), H, W). The caller must slice out exactly the class channels before calling this function; no implicit channel slicing happens here. Detection uses argmax, which is invariant to whether the values are raw logits or post-softmax probabilities, so either can be passed in. class_names (list[str]): Ordered list of class names (index i corresponds to channel i). target_class (list[str] | None): Classes to process. None processes all non-background classes (class-id >= 1). min_component_area (int): Minimum component size in *original* pixels. Scaled proportionally before BFS so that the threshold is consistent regardless of downscale_size. downscale_size (int): The downscaled map's longest dimension. Smaller values are faster but may merge or lose small regions. Returns: list[dict]: [{'bbox': [x1, y1, x2, y2], 'class': , 'score': }] (x1, y1) = top-left, (x2, y2) = bottom-right in original image coordinates. score = fraction of bbox pixels predicted as this class in the *original* class map. rrrrrrr"Nrci|]\}}|| SrRrRrs rrz:extract_bboxes_from_segmentation_numpy..rrc(g|]}|v|SrRrRr s rrWz:extract_bboxes_from_segmentation_numpy..s" D D DqAOOZ]OOOr)r+r7rr )rvrArrrrSroundr*ceilr)rr>r%rrr>r&rrr?rG)%rrrrr@rrorig_horig_wclass_map_fullscaleds_hds_w class_map_ds area_scale min_area_dsscale_rscale_crrrmask_dsrrrds_min_rds_min_cds_max_rds_max_c orig_min_r orig_min_c orig_max_r orig_max_cr r!rr s% @r&extract_bboxes_from_segmentation_numpyrZ>s9XK  I  A ) + + + >Z%5a%8 > >& > > > , + + !}H^A&q(9FFYxa000N S00 0E q#eFUN++,, - -D q#eFUN++,, - -D,^T4HHL+&6/2JaRW%7*%DEEFFGGKtmGtmGYq)27;;; HH;1G1GHHH X D D D DL D D D'   F8+33BH==27[QQQx(  C58[ 2Hh(X/00JX/00JVSG1C)D)D%E%EFFJVSG1C)D)D%E%EFFJ!J!6 :8M!MNC"*3(?;;<rZ__name__printrRrrrds ............ ; ;RZ ;s ;2: ; ; ; ; $RZ $BJ $ $ $ $===@x,x,RZx,x,TYx,disCx4T%S/%: :;;e=x,x,x,x,x+5+5 +5E+5Y^+5kopuvy{~v~plA+5+5+5+5\'BJ'3'2:''''RLBJLDLLLL\p"*p$ppppdBBBBH(00 0000  "*      2:##$ %#%RZ%rz%%%%2\*\J\Z\T%[! \ "#Y \  $Z \\\\H&'# $ %xx*xU5%567xx x # x  xxxZxxxxt:4 :4e:4 :4:4:4:4z22:2"*2222<<<< 1111hqqq<&* "# WW WcWs)d"W W  W  $Z WWWWt//s/c/VXV`////,;"*;;PTUYPZ;;;;B*."$! mmJm#Ym3i$&m m  m  $Z mmmm` z E  -T B B BCCCCCr