3jSSKJr SSKJr SSKrSSKJs Jr SSKJr SSK J r J r SSK J r Jr SSKJrJr SS KJr \R("/S Q\R*S 9r\R("/S Q\R*S 9r\R("/S Q\R*S 9rS$S%SjjrS$S%SjjrS$S&SjjrS$S&Sjjr"SS\R:5r"SS\R:5rS'S(Sjjr S)S*Sjjr!S+S,Sjjr""SS\R:5r#S-S.Sjjr$S/S0Sjjr%"SS\R:5r&S1S2Sjjr'"S S!\R:5r("S"S#\R:5r)g)3) annotations)OptionalN)nn)normalize_pixel_coordinatesnormalize_pixel_coordinates3d)create_meshgridcreate_meshgrid3d)spatial_expectation2dspatial_softmax2d)nms3d)rrrrrrrrrrrrrrrrrr r r r r r r r r )dtype)rrrrrrr r r rrrrrrr r r rrrrrrr r r )rrr rrr rrr rrr rrr rrr rrr rrr rrr cUc[R"S5n[XSUS9n[X0U5nUR SSSS5nU$)zGenerate a kernel to with window coordinates, residual to window center. Args: h: kernel height. w: kernel width. device: device, on which generate. Returns: conv_kernel [2x1xhxw] cpuFdevicerr )torchrrrpermute)hwr window_grid2d conv_kernels d/home/wildlama/miniconda3/lib/python3.13/site-packages/kornia/geometry/subpix/spatial_soft_argmax.py_get_window_grid_kernel2dr2sM~e$#A%?M/ !DM''1a3K c>Uc[R"S5n[R"SSXUS9nUS-S:waUS-nUS-S-nOUS-S- nUS-S-nUS-S:waUS-nUS-S-nOUS-S- nUS-S-nS[XT- Xv- -5- USSXE2Xg24'U$)zGenerate a kernel to return center coordinates, when applied with F.conv2d to 2d coordinates grid. Args: h: kernel height. w: kernel width. device: device, on which generate. Returns: conv_kernel [2x2xhxw]. rrrrr ?)rr rrzerosfloat)rrr center_kernelh_i1h_i2w_i1w_i2s r_get_center_kernel2dr)Fs~e$KK1a6:M 1uzAvQ!|Q!|Q!|1uzAvQ!|Q!|Q!|:=t{W[WbFc@d:dM&&$)TY67 rc Uc[R"S5 [R"SSXX#S9nUS-S:waUS-nUS-S-nOUS-S- nUS-S-nUS-S:waUS-nUS-S-nOUS-S- nUS-S-nUS-S:waUS-n US-S-n OUS-S- n US-S-n [Xe- X- -X- -5n SU - USSX2XV2Xx24'U$) zGenerate a kernel to return center coordinates, when applied with F.conv2d to 3d coordinates grid. Args: d: kernel depth. h: kernel height. w: kernel width. device: device, on which generate. Returns: conv_kernel [3x3xdxhxw]. rrrrrr r )rr rr!) drrrr$r%r&r'r(d_i1d_i2 center_nums r_get_center_kernel3dr/gs~ UKK1aA=M1uzAvQ!|Q!|Q!|1uzAvQ!|Q!|Q!|1uzAvQ!|Q!|Q!|  4 DEJKNQ[K[M)Y 49diGH rc Uc[R"S5n[XSUS9nUS:a)[R"SSXS9R USSS5nO[R "SSSSUS9n[R "URSXS5R5URUSSS5/S5nURSSSS5RS5nU$) zGenerate a kernel to return coordinates, residual to window center. Args: d: kernel depth. h: kernel height. w: kernel width. device: device, on which generate. Returns: conv_kernel [3x1xdxhxw] rTrr rrrr) rrrlinspaceviewr"catrepeat contiguousr unsqueeze)r+rrrgrid2dzgrid3drs r_get_window_grid_kernel3dr:s~e$ Q4 7F1u NN2q! 3 8 8Aq! D KK1a6 2 YYA!,7796==AqRS;TUWX YF..Aq!,66q9K rct^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) ConvSoftArgmax2dz{nn.Module that calculates soft argmax 2d per window. See :func: `~kornia.geometry.subpix.conv_soft_argmax2d` for details. cv>[TU]5 XlX lX0lX@lXPlX`lXplgN) super__init__ kernel_sizestridepadding temperaturenormalized_coordinateseps output_value) selfrBrCrDrErFrGrH __class__s rrAConvSoftArgmax2d.__init__s7 &  &&<#(rcURRSURSURSURSUR SUR SURSURS3$) N (kernel_size= , stride= , padding=, temperature=, normalized_coordinates=, eps=, output_value=)) rJ__name__rBrCrDrErFrGrHrIs r__repr__ConvSoftArgmax2d.__repr__s~~&&'D,,-.kk]#||n%++,-&&*&A&A%BC88* --.a 1 rc [UURURURURUR UR UR5$r?)conv_soft_argmax2drBrCrDrErFrGrHrIxs rforwardConvSoftArgmax2d.forwardsK!    KK LL     ' ' HH     r)rGrBrFrHrDrCrE)rrr r r`r T:0yE>F)rBtuple[int, int]rCrbrDrbrEtorch.Tensor | floatrFboolrGr#rHrdreturnNonerestrr\ torch.Tensorre0torch.Tensor | tuple[torch.Tensor, torch.Tensor] rU __module__ __qualname____firstlineno____doc__rArWr]__static_attributes__ __classcell__rJs@rr<r<s(."(#),/'+")$) )! ) * ) !% ))) ))&     rr<cz^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) ConvSoftArgmax3dz{nn.Module that calculates soft argmax 3d per window. See :func: `~kornia.geometry.subpix.conv_soft_argmax3d` for details. c >[T U]5 XlX lX0lX@lXPlX`lXplXl gr?) r@rArBrCrDrErFrGrHstrict_maxima_bonus) rIrBrCrDrErFrGrHrxrJs rrAConvSoftArgmax3d.__init__s= &  &&<#(#6 rcURRSURSURSURSUR SUR SURSURSURS 3$) NrMrNrOrPrQrR, strict_maxima_bonus=rSrT) rJrUrBrCrDrErFrGrxrHrVs rrWConvSoftArgmax3d.__repr__s~~&&'D,,-.kk]#||n%++,-&&*&A&A%BC88*##'#;#;"<= --.a 1 rc [UURURURURUR UR URUR5 $r?) conv_soft_argmax3drBrCrDrErFrGrHrxr[s rr]ConvSoftArgmax3d.forwardsT!    KK LL     ' ' HH     $ $  r)rGrBrFrHrDrxrCrErrrr r r rr FraTg)rBtuple[int, int, int]rCrrDrrErcrFrdrGr#rHrdrxr#rerfrgrirlrss@rrurus-6'0(1,/',!%(7)7%7& 7 * 7 !% 777#7 77*     rruc *[R"U5(d[S[U535e[ UR 5S:Xd[ SUR 35eUS::a[ SU35eUR uppUupURnURnURX-SX5n[XU5RU5n[XU5RU5nURSSS 9nUUR5- U- R5n[!X-5nU["R$"UXUS 9-U-nU["R$"UU-XUS 9-U- nURXUR'S 5UR'S 55n[)XS U5RU5R+SS SS 5n["R,"UUX#S 9n["R,"UUX#S 9nUUR/U5- nUUR/U5-nU(a2[1UR+SS S S5X5nUR+SS SS 5nURXS UR'S 5UR'S 55nU(aUU4$U$)a&Compute the convolutional spatial Soft-Argmax 2D over the windows of a given heatmap. .. math:: ij(X) = \frac{\sum{(i,j)} * exp(x / T) \in X} {\sum{exp(x / T) \in X}} .. math:: val(X) = \frac{\sum{x * exp(x / T) \in X}} {\sum{exp(x / T) \in X}} where :math:`T` is temperature. Args: input: the given heatmap with shape :math:`(N, C, H_{in}, W_{in})`. kernel_size: the size of the window. stride: the stride of the window. padding: input zero padding. temperature: factor to apply to input. normalized_coordinates: whether to return the coordinates normalized in the range of :math:`[-1, 1]`. Otherwise, it will return the coordinates in the range of the input shape. eps: small value to avoid zero division. output_value: if True, val is output, if False, only ij. Returns: Function has two outputs - argmax coordinates and the softmaxpooled heatmap values themselves. On each window, the function computed returns with shapes :math:`(N, C, 2, H_{out}, W_{out})`, :math:`(N, C, H_{out}, W_{out})`, where .. math:: H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[0] - (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor .. math:: W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[1] - (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor Examples: >>> input = torch.randn(20, 16, 50, 32) >>> nms_coords, nms_val = conv_soft_argmax2d(input, (3,3), (2,2), (1,1), output_value=True) &Input type is not a torch.Tensor. Got z-Invalid input shape, we expect BxCxHxW. Got: r;Temperature should be positive float or torch.Tensor. Got: r )rTdimkeepdimrCrDrrF)r is_tensor TypeErrortypelenshape ValueErrorrrr2r)toramaxdetachexpr#F avg_pool2dsizerrconv2d expand_asr)inputrBrCrDrErFrGrHbcrrkykxrrr$ window_kernelx_maxx_exp pool_coefden x_softmaxpool grid_globalgrid_global_pooled coords_maxs rrZrZszf ??5 ! !@e NOO u{{ q H VWWaVWbVcdeeJA! FB <PQJ=(( rc [R"U5(d[S[U535e[ UR 5S:Xd[ SUR 35eUS::a[ SU35eUR uppn UupnURnURnURX-SXU 5n[XUU5RU5n[XUU5RU5nURSSS 9nUUR5- U- R5n[!UU-U-5nU["R$"UR'U5XUS 9-U-n[)XU S US 9RU5R+SS SSS5n["R,"UUX#S 9n["R,"UUX#S 9nUUR/U5- nUUR/U5-nU(a5[1UR+SSSS S5XU 5nUR+SS SSS5nURXSUR3S5UR3S5UR3S 55nU(dU$U["R$"URUR355U-XUS 9-U- nUS:ahUR3S5nUR3S5nUU- S-n["R$"[5X5SUS5n U SS2SS2UUU- 24n USUU ---nURXUR3S5UR3S5UR3S 55nUU4$)aCompute the convolutional spatial Soft-Argmax 3D over the windows of a given heatmap. .. math:: ijk(X) = \frac{\sum{(i,j,k)} * exp(x / T) \in X} {\sum{exp(x / T) \in X}} .. math:: val(X) = \frac{\sum{x * exp(x / T) \in X}} {\sum{exp(x / T) \in X}} where ``T`` is temperature. Args: input: the given heatmap with shape :math:`(N, C, D_{in}, H_{in}, W_{in})`. kernel_size: size of the window. stride: stride of the window. padding: input zero padding. temperature: factor to apply to input. normalized_coordinates: whether to return the coordinates normalized in the range of :math:[-1, 1]`. Otherwise, it will return the coordinates in the range of the input shape. eps: small value to avoid zero division. output_value: if True, val is output, if False, only ij. strict_maxima_bonus: pixels, which are strict maxima will score (1 + strict_maxima_bonus) * value. This is needed for mimic behavior of strict NMS in classic local features Returns: Function has two outputs - argmax coordinates and the softmaxpooled heatmap values themselves. On each window, the function computed returns with shapes :math:`(N, C, 3, D_{out}, H_{out}, W_{out})`, :math:`(N, C, D_{out}, H_{out}, W_{out})`, where .. math:: D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] - (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor .. math:: H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] - (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor .. math:: W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] - (\text{kernel\_size}[2] - 1) - 1}{\text{stride}[2]} + 1\right\rfloor Examples: >>> input = torch.randn(20, 16, 3, 50, 32) >>> nms_coords, nms_val = conv_soft_argmax3d(input, (3, 3, 3), (1, 2, 2), (0, 1, 1)) rz/Invalid input shape, we expect BxCxDxHxW. Got: rrr )rrTrrFrrrrNr )rrrrrrrrrr2r/rr:rrrr#r avg_pool3dview_asr rconv3drrrr )!rrBrCrDrErFrGrHrxrrr+rrkzrrrrr$rrrrrrrrr in_levels out_levels skip_levels strict_maximas! rr~r~sVt ??5 ! !@e NOO u{{ q J5;;-XYYaVWbVcdeeKKMA!JBB <PR\RaRabcRdeJ  ALLEJJL!9E!A;gnooruuQA ',,Q/ % 2q8 &'ll53LaQWYZ&[ %aK*{:R,R&RS 2]BBB !&&q]-?-?-BMDVDVWXDY[h[m[mno[pqM } $$rcdUc[R"S5n[X5n[X25nU$)aCompute the Spatial Soft-Argmax 2D of a given input heatmap. Args: input: the given heatmap with shape :math:`(B, N, H, W)`. temperature: factor to apply to input. normalized_coordinates: whether to return the coordinates normalized in the range of :math:`[-1, 1]`. Otherwise, it will return the coordinates in the range of the input shape. Returns: the index of the maximum 2d coordinates of the give map :math:`(B, N, 2)`. The output order is x-coord and y-coord. Examples: >>> input = torch.tensor([[[ ... [0., 0., 0.], ... [0., 10., 0.], ... [0., 0., 0.]]]]) >>> spatial_soft_argmax2d(input, normalized_coordinates=False) tensor([[[1.0000, 1.0000]]]) r )rtensorr r )rrErF input_softoutputs rspatial_soft_argmax2drs10ll3' 0DJ0TF MrcH^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) SpatialSoftArgmax2di$zCompute the Spatial Soft-Argmax 2D of a given heatmap. See :func:`~kornia.geometry.subpix.spatial_soft_argmax2d` for details. cl>[TU]5 Uc[R"S5nXlX lg)Nr )r@rArrrErF)rIrErFrJs rrASpatialSoftArgmax2d.__init__*s.   ,,s+K)4,B#rchURRSURSURS3$)Nz temperature=rQrT)rJrUrErFrVs rrWSpatialSoftArgmax2d.__repr__1s>~~&&'4++,-&&*&A&A%B! E rcB[XRUR5$r?)rrErF)rIrs rr]SpatialSoftArgmax2d.forward8s$U,<,Y>YZZr)rFrENT)rEOptional[torch.Tensor]rFrdrerfrg)rrjrerjrlrss@rrr$s% CC [[rrc X-XU-- n X2-XT-- n X5-X-- n X -X;-- XL--n U R5U :n[R"X[R"U 55nXj-X7U-XX-- -- XGU-X-- --U- nXU-XX-- -Xk-- XCU-Xt-- --U- nXU-Xu-- -X3U-Xt-- -- Xl--U- nUUUU4$)uSolve H * [sx, sy, ss]^T = [r0, r1, r2]^T via Cramer's rule. H is symmetric: H = [[dxx, dxy, dxs], [dxy, dyy, dys], [dxs, dys, dss]]. All inputs are batched 1-D tensors of length N. Args: dxx: diagonal Hessian element (d²/dx²). dyy: diagonal Hessian element (d²/dy²). dss: diagonal Hessian element (d²/ds²). dxy: off-diagonal Hessian element (d²/dxdy). dxs: off-diagonal Hessian element (d²/dxds). dys: off-diagonal Hessian element (d²/dyds). r0: right-hand side component along x. r1: right-hand side component along y. r2: right-hand side component along s. eps: determinant magnitude below which the system is treated as singular. Near-singular systems can produce numerically unstable (huge) shifts. Returns: (sx, sy, ss, solved) where ``solved`` is a bool mask for well-conditioned systems (``|det| > eps``). Outputs for unsolved entries are numerically meaningless and should be discarded by the caller. )absrwhere ones_like)dxxdyydssdxydxsdysr0r1r2rGcf00cf01cf02detsolvedsafe_detsxsysss r_solve_cramer_sym3x3r<sF 9sy D 9sy D 9sy D *sz !CJ .C WWY_F{{6(<=H )c#X01 1C8ch;N4O OS[ [B cCH$ % 1C8bh;N4O OS[ [B rBH$ %Rx"(/B(C Cbi OS[ [B r2v rc [R"U5(d[S[U535eURS:wa[ SUR 35eUR upxpn URn URn Xx-nX-U -nX-n[R"XxSXXU S9n[R"XU S9RU SS5USS2SS2S4'[R"XU S9RSSU 5USS2SS2S4'[R"XU S9RSU S5USS2SS2S 4'UR5nU S:d U S:dU S:aUU4$UbUO [US S 5n[R"URXX55unnnnUR SnUn[R"U*US-U [RS9n[R "UUUS S 9unnnUR#S5nUR#S5nUR#S5nUR SnUR%S5UR%S5-R#S5nUR%S5UR%S5-R#S5n UR%S5UR%S5-R#S5n!UR%S5R'SU5R#S5n"US:UU S - :*-U S:-U U S - :*-U!S:-U!U S - :*-n#U"U#n$UU#n%U U#n&U!U#n'URS5n([(R+U 5U-[,R+U 5U --[.R+U 5-n)U$U-U%U--U&U --U'-n*U(U*R%S5U)R%S5-n+U+SS2S4n,U+SS2S4n-U+SS2S4n.U+SS2S4n/U+SS2S4n0U+SS2S4n1U+SS2S4n2U+SS2S4n3U+SS2S4n4U+SS2S4n5U+SS2S4n6U+SS2S4n7U+SS2S4n8U+SS2S4n9U+SS2S4n:U+SS2S4n;U+SS2S4nSU.U-- -n?SU0U/- -n@SU2U1- -nAU.S U,-- U--nBU0S U,-- U/-nCU2S U,-- U1-nDS!U6U5- U4- U3--nES!U:U9- U8- U7--nFS!U>U=- U<- U;--nG[1UBUCUDUEUFUGU?*U@*UA*5 unHnInJnKU?UH-U@UI--UAUJ--nLU$R SnM[R2"X-4S[R4U S"9nN[R"UM[R4U S"9UNU$U-U%U--U&U --U'-'UR5nOUR5nPUR5nQ[R6"U[R8U S"9nR[R:"UXS9nS[R:"UXS9nT[R:"UXS9nU[R:"UXS9nV[=U5GH:nWWOR?SU S - 5nXWPR?SU S - 5nYWQR?SU S - 5nZUU-UXU--UYU --UZ-n[WNU[R5n\U\S:n]U\R?SS#9n^WHU^n_WIU^n`WJU^naWLU^nbWKU^U]-ncWRUc-nRURR+U 5ndU_Ud-n_U`Ud-n`UaUd-na[R"URU_WS5nS[R"URU`WT5nT[R"URUaWU5nU[R"URUbWV5nVURU_U:-neURU_U*:-nfUQUeR5-UfR5- ngURUgS:-UgU S - :*-nRUgR?SU S- 5nQURU`U:-nhURU`U*:-niUPUhR5-UiR5- njURUjS:-UjU S - :*-nRUjR?SU S- 5nPU(dGMWRWaU:-nkURUaU*:-nlWOUkR5-UlR5- nmURUmS:-UmU S - :*-nRUmR?SU S- 5nOGM= WRWSRA5S$:*-WTRA5S$:*-WURA5S$:*-nRUU-nnUU-no[R"URWOR+U 5UU-UR+U 55UUnUoSUUU4'[R"URWQR+U 5US-UR+U 55UUnUoSUUU4'[R"URWPR+U 5UT-UR+U 55UUnUoS UUU4'S[R"URWV[RB"UV55-npURXX5UUOUPUQ4nqUqUp-UUnUoUUU4'US:a$UWnWoUUU4==UWRR+U 5-- ss'UU4$)%u Subpixel localization of 3D scale-space extrema via quadratic interpolation. For each NMS maximum the function fits a 3-D quadratic to the local :math:`3 \times 3 \times 3` neighbourhood and solves for the sub-voxel shift that maximises the fit. When the shift along any axis exceeds ``max_subpixel_shift`` the integer centre is moved one step in that direction and the solve is repeated — up to ``n_iters`` times. Unlike a naive iterative approach, all Hessian solves are precomputed once at the start for every voxel that any keypoint could possibly visit (the **dilated NMS neighbourhood**, an L\ :math:`\infty` ball of radius ``dilation_radius`` around each maximum). The subsequent iteration loop contains **no data-dependent Python control flow** and no GPU→CPU synchronisation, making the function fully compatible with ``torch.compile`` / CUDA graphs. The ``dilation_radius`` controls the precompute footprint and should be set to the maximum number of integer-centre moves expected per keypoint. With the default ``max_subpixel_shift=0.6`` almost all keypoints converge within 1 move, so the default ``dilation_radius=1`` (i.e. :math:`3^3 = 27` positions per maximum) is sufficient. Use ``dilation_radius=2`` (:math:`5^3 = 125`) for extra safety. Setting it equal to ``n_iters`` recovers the original behaviour but is much slower on large images. Args: input: response pyramid with shape :math:`(B, C, D, H, W)`. n_iters: maximum number of localization iterations per keypoint. strict_maxima_bonus: value added to ``y_max`` at NMS-maximum positions so that strict maxima are preferred during top-K selection. max_subpixel_shift: threshold above which the integer centre is moved one step and another iteration is run. precomputed_nms_mask: optional bool tensor of shape :math:`(B, C, D, H, W)` — pass the result of :func:`~kornia.geometry.subpix.nms3d` to skip the internal NMS call. dilation_radius: L\ :math:`\infty` radius (in voxels) of the neighbourhood around each NMS maximum where the Hessian solve is precomputed. Keypoints that attempt to move farther than this are marked invalid. allow_scale_steps: if ``True`` (default), the iterative shift is also applied along the scale (depth) axis; set to ``False`` to keep the keypoint on its original scale level. Returns: Tuple ``(coords_max, y_max)``: * ``coords_max`` — shape :math:`(B, C, 3, D, H, W)`, refined ``[scale, x(width), y(height)]`` coordinates for each NMS maximum; non-maximum positions keep their grid coordinates. * ``y_max`` — shape :math:`(B, C, D, H, W)`, quadratically corrected response with optional strict-maxima bonus. Example: >>> input = torch.randn(2, 3, 5, 64, 64) >>> coords, vals = conv_quad_interp3d(input, n_iters=5) >>> coords.shape torch.Size([2, 3, 3, 5, 64, 64]) >>> vals.shape torch.Size([2, 3, 5, 64, 64]) rr.Invalid input shape, expected BxCxDxHxW. Got: rrrr NrrrTij)indexingr  r ?@?rr)min?)"rrrrndimrrrremptyaranger2cloner rlongmeshgridreshaper6expand _PATCH_DDr _PATCH_DH _PATCH_DWrfullint32onesrdr"rangeclampr zeros_like)rrn_itersrxmax_subpixel_shiftprecomputed_nms_maskdilation_radiusallow_scale_stepsBCDHWrrBCDHWHWry_maxnms_maskbc_idxd_idxh_idxw_idxNroffsodohowKd_dilh_dilw_dilbc_dilkeepbc_ud_uh_uw_uinp_flat patch_offsets center_flatpatchc000p_xmp_xpp_ymp_ypp_smp_spp_xm_ymp_xp_ymp_xm_ypp_xp_ypp_xm_smp_xp_smp_xm_spp_xp_spp_ym_smp_yp_smp_ym_spp_yp_spgxgygsrrrrrrsx_usy_uss_usol_ugds_uNKlutd_curh_curw_curvalidshift_xshift_yshift_sgrad_dot_shift_dihiwiflat_qlut_idxin_lutidx_saferrrgdssolvfmove_pxmove_nxnew_wmove_pymove_nynew_hmove_psmove_nsnew_db_idxc_idxval_correction val_centersr rconv_quad_interp3drjls F ??5 ! !@e NOO zzQI%++WXXKKMA! \\F KKE B %!)C BQ1aAEJJ,,quEJJ1aQRSJq!Qw,,quEJJ1aQRSJq!Qw,,quEJJ1aQRSJq!Qw KKME1uAQ5  (<'G#USXZceiMjH"'++hmmB1.H"IFE5% QA A <<AE& CDdD4@JBB BB BB BB  A__Q ",,q/ 1 : :2 >E __Q ",,q/ 1 : :2 >E __Q ",,q/ 1 : :2 >E   a ' 'A . 6 6r :F QJ5AE> *eqj 9Ua!e^ LPUYZPZ [_dhilmhm_m nD $N>N~>^__NB1(u)DEJ/9N/JE%ue +,Q eUE5%/04G%((SX/4YY0 u rcx^\rSrSrSrSSU4SjjjrS SjrS S SjjrSrU=r $) ConvQuadInterp3diputSubpixel localization of 3D scale-space extrema via quadratic interpolation. Wraps :func:`~kornia.geometry.subpix.conv_quad_interp3d`. The Hessian system is solved once for each voxel in the dilated NMS neighbourhood (no dense precomputation over the whole volume), then the shift chain is followed by table lookup with no GPU→CPU synchronisation — making the module compatible with ``torch.compile`` and CUDA graphs. Args: n_iters: maximum localization iterations per keypoint. strict_maxima_bonus: score bonus at NMS-maximum positions. max_subpixel_shift: shift threshold that triggers integer centre move. c^>[TU]5 XlX lX0lX@lXPlgr?)r@rArrxrr r )rIrrxrr r rJs rrAConvQuadInterp3d.__init__s-  #6 "4.!2rc URRSURSURSURSUR SUR S3 $)N (n_iters=r{, max_subpixel_shift=, dilation_radius=, allow_scale_steps=rT)rJrUrrxrr r rVs rrWConvQuadInterp3d.__repr__sp~~&&'(||n%##'#;#;"<=""&"9"9!:;#3345!!%!7!7 8  ; rc [UURURURUURUR 5$r?)rjrrxrr r rIr\rs rr]ConvQuadInterp3d.forwardsB" LL  $ $  # #   " "  r)r r rrrx)r$@333333?r T) rintrxr#rr#r rzr rdrerfrgr?r\rjrrre!tuple[torch.Tensor, torch.Tensor]rlrss@rrlrlps  %)$' "& 3 3# 3" 3  3  3  3 3 OS    5K  *   rrlc [R"U5(d[S[U535eURS:wa[ SUR 35eUR upxpn URn URn [R"XxSXXU S9n[R"XU S9RU SS5USS2SS2S4'[R"XU S9RSSU 5USS2SS2S4'[R"XU S9RSU S5USS2SS2S 4'UR5nU S:d U S:dU S:aX4$URXx-XU 5nX-U -nX-nUbUO [US S 5RXx-XU 5n[R"U5unnnnUR SnUb=UU:a7UUUUU4n[R "UUS 9unnUUnUUnUUnUUnUn["R%U 5U-[&R%U 5U --[(R%U 5-nUR5nUR5nUR5n[R*"U[R,U S 9n [R."UXS9n![R."UXS9n"[R."UXS9n#[R."UXS9n$URS5n%UU-n&[1U5GHPnUR3SU S - 5n'UR3SU S - 5n(UR3SU S - 5n)U%U&U'U--U(U --U)-R5S5UR5S5-n*U*SS2S4n+U*SS2S4n,U*SS2S4n-U*SS2S4n.U*SS2S4n/U*SS2S4n0U*SS2S4n1U*SS2S4n2U*SS2S4n3U*SS2S4n4U*SS2S4n5U*SS2S4n6U*SS2S4n7U*SS2S4n8U*SS2S4n9U*SS2S4n:U*SS2S4n;U*SS2S4nSU/U.- -n?SU1U0- -n@U-S U+-- U,-nAU/S U+-- U.-nBU1S U+-- U0-nCS!U5U4- U3- U2--nDS!U9U8- U7- U6--nES!U=U<- U;- U:--nF[7UAUBUCUDUEUFU>*U?*U@*5 unGnHnInJU UJ-n U R%U 5nKUGUK-nGUHUK-nHUIUK-nI[R"U UGU!5n![R"U UHU"5n"[R"U UIU#5n#[R"U U>UG-U?UH--U@UI--U$5n$U UGU:-nLU UGU*:-nMUULR95-UMR95- nNU UNS:-UNU S - :*-n UNR3SU S- 5nU UHU:-nOU UHU*:-nPUUOR95-UPR95- nQU UQS:-UQU S - :*-n UQR3SU S- 5nU(dGMU WIU:-nRU UIU*:-nSUURR95-USR95- nTU UTS:-UTU S - :*-n UTR3SU S- 5nGMS U U!R;5S":*-U"R;5S":*-U#R;5S":*-n UU-nUUU-nV[R"U UR%U 5U#-UR%U 55nW[R"U UR%U 5U!-UR%U 55nX[R"U UR%U 5U"-UR%U 55nYUWUUUUVSUUU4'UXUUUUVSUUU4'UYUUUUVS UUU4'S[R"U U$[R<"U$55-nZUUUUU4n[U[UZ-UUUUVUUU4'US:a$UWUWVUUU4==UU R%U 5-- ss'X4$)#u Iterative subpixel localization of 3D extrema via quadratic interpolation. Unlike :func:`conv_quad_interp3d`, which pre-computes the Hessian solve for all voxels reachable from NMS maxima and then follows shifts by table lookup, this function explicitly re-extracts the :math:`3 \times 3 \times 3` patch at each NMS maximum and iterates up to ``n_iters`` times. When the estimated subpixel shift along any spatial or scale axis exceeds ``max_subpixel_shift`` the integer center is moved one step in that direction and the solve is repeated — matching the localization loop from the HessAff / SIFT family of detectors. Args: input: response pyramid with shape :math:`(B, C, D, H, W)`. n_iters: maximum number of localization iterations per keypoint. strict_maxima_bonus: value added to ``y_max`` at NMS-maximum positions so that strict maxima are preferred when selecting the top-K keypoints. max_subpixel_shift: if the estimated shift along any axis is larger than this threshold the integer center is displaced and another iteration is run. allow_scale_steps: if ``True`` (default), the iterative shift is also applied along the scale (depth) axis; set to ``False`` to keep the keypoint on its original scale level. precomputed_nms_mask: optional bool tensor of shape :math:`(B, C, D, H, W)` — pass the result of :func:`~kornia.geometry.subpix.nms3d` to skip the internal NMS call. max_candidates: if given, only the top-``max_candidates`` NMS maxima (ranked by pre-refinement response) are processed. The rest keep their grid-coordinate values. This is a **CPU speed-up knob**: for large images the number of 3-D NMS maxima can be 10x-100x larger than the desired number of keypoints, making the per-candidate gather+solve loop the dominant CPU cost. Setting ``max_candidates = num_features * 5`` (say) dramatically reduces that work at the cost of occasionally missing a feature whose response rank would have improved after refinement. Returns: A tuple ``(coords_max, y_max)`` where * ``coords_max`` has shape :math:`(B, C, 3, D, H, W)` and stores the refined coordinates ``[scale, x, y]`` for every position in the input. Non-NMS positions keep their original grid coordinates. * ``y_max`` has shape :math:`(B, C, D, H, W)` and stores the quadratically corrected response values (with the optional strict-maxima bonus added). Example: >>> input = torch.randn(2, 3, 3, 8, 8) >>> coords, vals = iterative_quad_interp3d(input, n_iters=5) >>> coords.shape torch.Size([2, 3, 3, 3, 8, 8]) >>> vals.shape torch.Size([2, 3, 3, 8, 8]) rrrrrr NrrrT)krrrrrrrrrrrrrrrrrrrrrr)rrrrrrrrrrrr2rrr rtopkrrrrrrdr"rrr6rrrr)\rrrxrr rmax_candidatesr r r rrrrrrinprrnms_flatrrrrr cand_valsrRr$r*rJrKrLrMrNrOrPrQr)bc_based_sh_sw_sr,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrrrrrrrrrrvalid_f move_pos_x move_neg_xr_ move_pos_y move_neg_yrb move_pos_s move_neg_srerfrgfinal_sfinal_xfinal_yrhris\ riterative_quad_interp3drsv ??5 ! !@e NOO zzQI%++WXXKKMA! \\F KKEQ1aAEJJ,,quEJJ1aQRSJq!Qw,,quEJJ1aQRSJq!Qw,,quEJJ1aQRSJq!Qw KKME1uAQ  --qQ 'C %!)C B(<(H$eTY[dfjNkqq qQH#(++h"7FE5% QA!a.&8ue34 **Y.94d d d  LL(2- V0Dq0HH9<JueQue347>JueQue347>JueQue345;;une>N>N~>^__NVUE501J/9N/JE%ue +,Q eUE5%/04G%((SX/4YY0  rcx^\rSrSrSrSSU4SjjjrS SjrS S SjjrSrU=r $) IterativeQuadInterp3di}zIterative subpixel localization of 3D extrema via quadratic interpolation. See :func:`~kornia.geometry.subpix.iterative_quad_interp3d` for details. c^>[TU]5 XlX lX0lX@lXPlgr?)r@rArrxrr r)rIrrxrr rrJs rrAIterativeQuadInterp3d.__init__s-  #6 "4!2,rc URRSURSURSURSUR SUR S3 $)Nrpr{rqrs, max_candidates=rT)rJrUrrxrr rrVs rrWIterativeQuadInterp3d.__repr__sp~~&&'(||n%##'#;#;"<=""&"9"9!:;!!%!7!7 89"112!  5 rc [UURURURURUUR S9$)Nrr)rrrxrr rrvs rr]IterativeQuadInterp3d.forwardsB ' LL  $ $  # #  " "!5..  r)r rrrrx)rrxryTN) rrzrxr#rr#r rdr Optional[int]rerfrgr?r{rlrss@rrr}s%)$'"&(, - -# -" -  - & -  - - 8<    5   +   rrc^\rSrSrSrSrSS U4SjjjrS SjrS S SjjrSr U=r $) AdaptiveQuadInterp3diuSubpixel localization of 3D scale-space extrema with automatic backend selection. Wraps :func:`~kornia.geometry.subpix.conv_quad_interp3d` and :func:`~kornia.geometry.subpix.iterative_quad_interp3d`, choosing the faster backend based on the input device and the requested ``mode``. Benchmarks show: * **GPU** — :func:`conv_quad_interp3d` is 1.5-2x faster due to better parallelism on the batched gather+solve. * **CPU** — :func:`iterative_quad_interp3d` is faster for large images because it processes only the NMS maxima directly without any dilation/dedup overhead. Args: mode: backend selection strategy. * ``"patch"`` — always use :func:`iterative_quad_interp3d`. * ``"conv"`` — always use :func:`conv_quad_interp3d`. * ``"auto"`` — use ``"conv"`` when the input is on a CUDA device, ``"patch"`` otherwise. n_iters: maximum localization iterations per keypoint. strict_maxima_bonus: score bonus added at NMS-maximum positions. max_subpixel_shift: integer-centre move threshold. dilation_radius: L\ :math:`\infty` precompute radius for ``"conv"`` mode (ignored in ``"patch"`` mode). max_candidates: if set, only the top-``max_candidates`` NMS maxima by pre-refinement response are processed in ``"patch"`` mode. Has no effect in ``"conv"`` mode. Useful on CPU when the number of 3-D NMS maxima greatly exceeds the desired number of keypoints (see :func:`iterative_quad_interp3d`). Example: >>> inp = torch.randn(1, 1, 3, 64, 64) >>> subpix = AdaptiveQuadInterp3d(mode="auto") >>> coords, vals = subpix(inp) >>> coords.shape torch.Size([1, 1, 3, 3, 64, 64]) >>> vals.shape torch.Size([1, 1, 3, 64, 64]) )r,convautoc>[TU]5 XR;a[SURSUS35eXlX lX0lX@lXPlX`l Xpl g)Nzmode must be one of z, got '') r@rAMODESrmoderrxrr r r) rIrrrxrr r rrJs rrAAdaptiveQuadInterp3d.__init__sa  zz !3DJJ+L199 % ((''$$$&& ' LL  $ $  # #  " "!5..  r)r r rrrrrx)rrrxryr TN)rrhrrzrxr#rr#r rzr rdrrrerfrgr?r{) rUrmrnrorprrArWr]rqrrrss@rrrs(T &E%)$' "&(,---# - " -  - -&- --*  8<  5  +   rrr?)rrzrrzrOptional[torch.device]rerj) r+rzrrzrrzrrrerjr_)rrjrBrbrCrbrDrbrErcrFrdrGr#rHrdrerkr)rrjrBrrCrrDrrErcrFrdrGr#rHrdrxr#rerkr)rrjrErrFrdrerj)gHz>)rrjrrjrrjrrjrrjrrjrrjrrjrrjrGr#rez=tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor])rrxryNr T)rrjrrzrxr#rr#rrr rzr rdrer|)rrxryTNN)rrjrrzrxr#rr#r rdrrrrrer|)* __future__rtypingrrtorch.nn.functionalr functionalrkornia.geometry.conversionsrrkornia.geometry.gridrr dsntr r nmsr rrrrrrr)r/r:Moduler<rurZr~rrrrjrlrrrrrrsz$# bC: LL^ **   LL^ **   LL^ **  (B%P20 ryy0 f4 ryy4 r$*$%(+#'o o o o o & o ! o oo6oh)2#,$-(+#(!$~% ~%%~% !~%" ~% & ~% ! ~% ~%~%~%6~%Dei &<]a>["))[D- - - -  -  -  - - - - -C-d!% #37"A A AA A 1 A  AA'AH3 ryy3 p!% #"37$(T T TT T  T 1 T"T'Tn, BII, ^f 299f r