o oir=@sddlmZddlZddlZddlmmZddlm Z m Z m Z m Z m Z mZmZddlmZmZmZddlmZmZgdZd-d d ZGd d d e ZGd dde ZGddde Zd.d/ddZd0d1ddZ d0d2d"d#Zd3d%d&Zd4d'd(Z d0d2d)d*Z!d5d+d,Z"dS)6) annotationsN)ModuleTensoronespadstacktensorzeros) KORNIA_CHECKKORNIA_CHECK_IS_TENSORKORNIA_CHECK_SHAPE)filter2dgaussian_blur2d)PyrDownPyrUp ScalePyramidbuild_laplacian_pyramid build_pyramidpyrdownpyrupupscale_doublereturnrcCs,tgdgdgdgdgdggdS)z&Return a pre-computed gaussian kernel.)?@@rr)r0@8@rr)rrgB@rrgp@)rrrU/home/ubuntu/.local/lib/python3.10/site-packages/kornia/geometry/transform/pyramid.py_get_pyramid_gaussian_kernel)s rcs.eZdZdZddfd d ZdddZZS)ra3Blur a tensor and downsamples it. Args: border_type: the padding mode to be applied before convolving. The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. align_corners: interpolation flag. factor: the downsampling factor Return: the downsampled tensor. Shape: - Input: :math:`(B, C, H, W)` - Output: :math:`(B, C, H / 2, W / 2)` Examples: >>> input = torch.rand(1, 2, 4, 4) >>> output = PyrDown()(input) # 1x2x2x2 reflectF@ border_typestr align_cornersboolfactorfloatrNonecs t||_||_||_dSN)super__init__r"r$r&)selfr"r$r& __class__rrr+Rs  zPyrDown.__init__inputrcCst||j|j|jSr))rr"r$r&r,r/rrrforwardXszPyrDown.forwardr Fr!)r"r#r$r%r&r'rr(r/rrr__name__ __module__ __qualname____doc__r+r1 __classcell__rrr-rr;srcs.eZdZdZddfd d ZdddZZS)ra Upsample a tensor and then blurs it. Args: borde_type: the padding mode to be applied before convolving. The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. align_corners: interpolation flag. Return: the upsampled tensor. Shape: - Input: :math:`(B, C, H, W)` - Output: :math:`(B, C, H * 2, W * 2)` Examples: >>> input = torch.rand(1, 2, 4, 4) >>> output = PyrUp()(input) # 1x2x8x8 r Fr"r#r$r%rr(cst||_||_dSr))r*r+r"r$)r,r"r$r-rrr+rs  zPyrUp.__init__r/rcCst||j|jSr))rr"r$r0rrrr1wz PyrUp.forwardr F)r"r#r$r%rr(r3r4rrr-rr\srcsNeZdZdZ d d!fdd Zd"ddZd#ddZd$ddZd%ddZZ S)&raCreate an scale pyramid of image, usually used for local feature detection. Images are consequently smoothed with Gaussian blur and downscaled. Args: n_levels: number of the levels in octave. init_sigma: initial blur level. min_size: the minimum size of the octave in pixels. double_image: add 2x upscaled image as 1st level of pyramid. OpenCV SIFT does this. Returns: 1st output: images 2nd output: sigmas (coefficients for scale conversion) 3rd output: pixelDists (coefficients for coordinate conversion) Shape: - Input: :math:`(B, C, H, W)` - Output 1st: :math:`[(B, C, NL, H, W), (B, C, NL, H/2, W/2), ...]` - Output 2nd: :math:`[(B, NL), (B, NL), (B, NL), ...]` - Output 3rd: :math:`[(B, NL), (B, NL), (B, NL), ...]` Examples: >>> input = torch.rand(2, 4, 100, 100) >>> sp, sigmas, pds = ScalePyramid(3, 15)(input) 皙?Fn_levelsint init_sigmar'min_size double_imager%rr(csNt||_d|_||_||_|dd|_ddt|j|_||_ dS)Nr<r) r*r+r? extra_levelsrArBborderr' sigma_steprC)r,r?rArBrCr-rrr+s  zScalePyramid.__init__r#cCsF|jjd|jd|jd|jd|jd|jd|jd|jdS) Nz (n_levels=z , init_sigma=z , min_size=z, extra_levels=z , border=z , sigma_step=z, double_image=)) r.r5r?rArBrFrGrHrC)r,rrr__repr__s zScalePyramid.__repr__sigmacCs(td|d}|ddkr|d7}|S)Ng @rrDrrE)r@)r,rKksizerrrget_kernel_sizes zScalePyramid.get_kernel_sizer/rtuple[Tensor, float, float]cCsd}d}|jrt|}d}|d9}n|}|j|kr;tt|jd|dd}||}t|||f||f}|j}n|}|||fS)Nrg?r!rDg{Gz?)rCrrAmaxmathsqrtrMr)r,r/pixel_distance cur_sigmaxrKrL cur_levelrrrget_first_levels    zScalePyramid.get_first_levelrT/tuple[list[Tensor], list[Tensor], list[Tensor]]cCs|\}}}}||\}}}|t||j|j|j|jg}|t||j|j|j|jg}|gg} d} | dd}td|j|jD]S} |t |j dd} | | } t | |d|d} | ddkrw| d7} t|| | f| | f}||j 9}| d|||ddd| f<||ddd| f<qN| d|j }|ddddddddddf}|d9}|j}t |d|d|jkrn1| |g||t||j|j|j||t||j|j|j| d7} q?d d | D}|||fS) NrTrErDrr<r!cSsg|]}t|dqS)rD)r).0irrr sz(ScalePyramid.forward..)sizerVrr?rFtodevicedtyperangerPrQrHrMminrappendrArBtorch)r,rTbs_rUrSrRsigmas pixel_distspyroct_idx level_idxrKrL_pyrnextOctaveFirstLevel output_pyrrrrr1s@((    $ && zScalePyramid.forward)r<r=r>F) r?r@rAr'rBr@rCr%rr()rr#)rKr'rr@)r/rrrN)rTrrrW) r5r6r7r8r+rJrMrVr1r9rrr-rr{s rr Fr!r/r"r#r$r%r&r'c Cs`t|gdt}|j\}}}}t|||}tj|tt||tt||fd|d} | S)aBlur a tensor and downsamples it. .. image:: _static/img/pyrdown.png Args: input: the tensor to be downsampled. border_type: the padding mode to be applied before convolving. The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. align_corners: interpolation flag. factor: the downsampling factor Return: the downsampled tensor. Examples: >>> input = torch.arange(16, dtype=torch.float32).reshape(1, 1, 4, 4) >>> pyrdown(input, align_corners=True) tensor([[[[ 3.7500, 5.2500], [ 9.7500, 11.2500]]]]) BCHWbilinearr\moder$)r rshaper F interpolater@r') r/r"r$r&kernelreheightwidthx_bluroutrrrrs rc CsPt|gdt}|j\}}}}tj||d|dfd|d}t|||}|S)aUpsample a tensor and then blurs it. .. image:: _static/img/pyrup.png Args: input: the tensor to be downsampled. border_type: the padding mode to be applied before convolving. The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. align_corners: interpolation flag. Return: the downsampled tensor. Examples: >>> input = torch.arange(4, dtype=torch.float32).reshape(1, 1, 2, 2) >>> pyrup(input, align_corners=True) tensor([[[[0.7500, 0.8750, 1.1250, 1.2500], [1.0000, 1.1250, 1.3750, 1.5000], [1.5000, 1.6250, 1.8750, 2.0000], [1.7500, 1.8750, 2.1250, 2.2500]]]]) rnrDrsrt)r rrvrwrxr ) r/r"r$ryrerzr{x_upr|rrrr#s  r max_levelr@ list[Tensor]cCsnt|gdtt|tp|dkd|g}||t|dD]}|d}t|||}||q#|S)a Construct the Gaussian pyramid for a tensor image. .. image:: _static/img/build_pyramid.png The function constructs a vector of images and builds the Gaussian pyramid by recursively applying pyrDown to the previously built pyramid layers. Args: input : the tensor to be used to construct the pyramid. max_level: 0-based index of the last (the smallest) pyramid layer. It must be non-negative. border_type: the padding mode to be applied before convolving. The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. align_corners: interpolation flag. Shape: - Input: :math:`(B, C, H, W)` - Output :math:`[(B, C, H, W), (B, C, H/2, W/2), ...]` rnr7Invalid max_level, it must be a positive integer. Got: rErX)r r isinstancer@rbr`r)r/rr"r$pyramidreimg_currimg_downrrrrGs   rrTcCst|o ||d@ SNrE)r%rTrrris_powerof_tworsrcCsd|d>Sr) bit_lengthrrrrfind_next_powerof_twowr:rc Cst|gdtt|tp|dkd||d}|d}t|p)t| }|rAdt||dt||f}t||d}t||||}g} t |dD]} t || d||} || | } | | qP| |d| S) a7Construct the Laplacian pyramid for a tensor image. The function constructs a vector of images and builds the Laplacian pyramid by recursively computing the difference after applying pyrUp to the adjacent layer in its Gaussian pyramid. See :cite:`burt1987laplacian` for more details. Args: input : the tensor to be used to construct the pyramid with shape :math:`(B, C, H, W)`. max_level: 0-based index of the last (the smallest) pyramid layer. It must be non-negative. border_type: the padding mode to be applied before convolving. The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. align_corners: interpolation flag. Return: Output: :math:`[(B, C, H, W), (B, C, H/2, W/2), ...]` rnrrrDr<r rErX) r r rr@r\rrrrr`rrb) r/rr"r$hwrequire_paddingpaddinggaussian_pyramidlaplacian_pyramidrZ img_expand laplacianrrrr{s&     rcCst|t|gd|jdd|jdd|jddf}t||j|jd}||dddddddf<|dddddddfdddf|dddddddfd|dddddddfdddf<|dddddf|dddddf<|ddddddfdddddf|ddddddfd|ddddddfdddddf<|ddddf|ddddf<|S) aUpscale image by the factor of 2, even indices maps to original indices. Odd indices are linearly interpolated from the even ones. Args: x: input image. Shape: - Input: :math:`(*, H, W)` - Output :math:`(*, H, W)` )*rqrrNrDrX)r^r_.rE)r r rvr r^r_)rT double_shapeupscaledrrrrs *f$l r)rrr2) r/rr"r#r$r%r&r'rrr;)r/rr"r#r$r%rr) r/rrr@r"r#r$r%rr)rTr@rr%)rTr@rr@)rTrrr)# __future__rrPrctorch.nn.functionalnn functionalrw kornia.corerrrrrrr kornia.core.checkr r r kornia.filtersr r__all__rrrrrrrrrrrrrrrs* $ !  )% +  6