a dA @s(dZddlmZddlZddlmZddlmmZddl m Z ddl m Z ddl mZmZmZmZmZddlmZdd lmZmZmZmZgd Zdejejeejd d dZdejejeejd ddZdejejejejeejdddZGdddej Z!deeejeje"e"edddZ#dS)z8Module containing operators to work on RGB-Depth images.)UnionN)spatial_gradient)create_meshgrid) PinholeCamera cam2pixel pixel2camproject_pointsunproject_points)normalize_pixel_coordinates)compose_transformationsconvert_points_to_homogeneousinverse_transformationtransform_points) depth_to_3ddepth_to_normalswarp_frame_depth depth_warp DepthWarperF)depth camera_matrixnormalize_pointsreturnc Cst|tjs tdt|dt|jdkr<|jddksLtd|jt|tjsltdt|dt|jdkr|jd d d kstd |jd|j\}}}}t||d d}| |j  |j }| dddd}|d d d d f}t ||||d} | ddddS)aCompute a 3d point per pixel given its depth value and the camera intrinsics. Args: depth: image tensor containing a depth value per pixel with shape :math:`(B, 1, H, W)`. camera_matrix: tensor containing the camera intrinsics with shape :math:`(B, 3, 3)`. normalize_points: whether to normalise the pointcloud. This must be set to `True` when the depth is represented as the Euclidean ray length from the camera position. Return: tensor with a 3d point per pixel of the same resolution as the input :math:`(B, 3, H, W)`. Example: >>> depth = torch.rand(1, 1, 4, 4) >>> K = torch.eye(3)[None] >>> depth_to_3d(depth, K).shape torch.Size([1, 3, 4, 4]) ,Input depht type is not a torch.Tensor. Got .r2Input depth musth have a shape (B, 1, H, W). Got: 4Input camera_matrix type is not a torch.Tensor. Got Nrr6Input camera_matrix must have a shape (B, 3, 3). Got: FZnormalized_coordinatesr) normalize) isinstancetorchTensor TypeErrortypelenshape ValueErrorrtodevicedtypepermuter ) rrr_heightwidthZ points_2dZ points_depthcamera_matrix_tmpZ points_3dr6^/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/kornia/geometry/depth.pyrs"   rcCst|tjs tdt|dt|jdkr<|jddksLtd|jt|tjsltdt|dt|jdkr|jd d d kstd |jdt|||}t |}|d d d d d f|d d d d df}}tj ||dd}t j |dddS)aCompute the normal surface per pixel. Args: depth: image tensor containing a depth value per pixel with shape :math:`(B, 1, H, W)`. camera_matrix: tensor containing the camera intrinsics with shape :math:`(B, 3, 3)`. normalize_points: whether to normalise the pointcloud. This must be set to `True` when the depth is represented as the Euclidean ray length from the camera position. Return: tensor with a normal surface vector per pixel of the same resolution as the input :math:`(B, 3, H, W)`. Example: >>> depth = torch.rand(1, 1, 4, 4) >>> K = torch.eye(3)[None] >>> depth_to_normals(depth, K).shape torch.Size([1, 3, 4, 4]) rrrrrrrrr Nr!r"rdimr$)r9p) r&r'r(r)r*r+r,r-rrZcrossFr%)rrrZxyzZ gradientsabZnormalsr6r6r7rAs    .r) image_src depth_dst src_trans_dstrrrc Cst|tjs tdt|dt|jdks>td|jt|tjs^tdt|dt|jdkrz|jddkstd|jt|tjstd t|dt|jd kr|jd d d kstd|jdt|tjstdt|dt|jd kr |jd d dks2td|jdt|||}| ddd d}t |d d d f|}|d d d d f}t ||}|jd d \} } t || | } t j|| ddS)acWarp a tensor from a source to destination frame by the depth in the destination. Compute 3d points from the depth, transform them using given transformation, then project the point cloud to an image plane. Args: image_src: image tensor in the source frame with shape :math:`(B,D,H,W)`. depth_dst: depth tensor in the destination frame with shape :math:`(B,1,H,W)`. src_trans_dst: transformation matrix from destination to source with shape :math:`(B,4,4)`. camera_matrix: tensor containing the camera intrinsics with shape :math:`(B,3,3)`. normalize_points: whether to normalise the pointcloud. This must be set to ``True`` when the depth is represented as the Euclidean ray length from the camera position. Return: the warped tensor in the source frame with shape :math:`(B,3,H,W)`. z0Input image_src type is not a torch.Tensor. Got rrz6Input image_src musth have a shape (B, D, H, W). Got: z0Input depht_dst type is not a torch.Tensor. Got rrz6Input depth_dst musth have a shape (B, 1, H, W). Got: z4Input src_trans_dst type is not a torch.Tensor. Got rr N)rrz6Input src_trans_dst must have a shape (B, 4, 4). Got: rr!r"rr$T align_corners)r&r'r(r)r*r+r,r-rr1rr r r; grid_sample) r>r?r@rrZ points_3d_dstZ points_3d_srcr5Z points_2d_srcr3r4Zpoints_2d_src_normr6r6r7rls0     $   rcseZdZdZdeeeeeedfdd Ze eee j dd d Z edd d d Z ddZe j dddZe j e j dddZe j e j e j dddZZS)raBWarp a patch by depth. .. math:: P_{src}^{\{dst\}} = K_{dst} * T_{src}^{\{dst\}} I_{src} = \\omega(I_{dst}, P_{src}^{\{dst\}}, D_{src}) Args: pinholes_dst: the pinhole models for the destination frame. height: the height of the image to warp. width: the width of the image to warp. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. bilinearzerosT) pinhole_dstr3r4mode padding_moderBcsRt||_||_||_||_d|_||_||_d|_ d|_ | |||_ dS)Ngư>) super__init__r4r3rGrHZepsrB _pinhole_dst _pinhole_src _dst_proj_src_create_meshgridgrid)selfrFr3r4rGrHrB __class__r6r7rJs zDepthWarper.__init__)r3r4rcCst||dd}t|S)NFr#)rr )r3r4rOr6r6r7rNszDepthWarper._create_meshgrid) pinhole_srcrcCspt|jts tdt|jt|ts>> # pinholes camera models >>> pinhole_dst = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4), ... torch.tensor([32]), torch.tensor([32])) >>> pinhole_src = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4), ... torch.tensor([32]), torch.tensor([32])) >>> # create the depth warper, compute the projection matrix >>> warper = DepthWarper(pinhole_dst, 32, 32) >>> _ = warper.compute_projection_matrix(pinhole_src) >>> # warp the destination frame to reference by depth >>> depth_src = torch.ones(1, 1, 32, 32) # Nx1xHxW >>> image_dst = torch.rand(1, 3, 32, 32) # NxCxHxW >>> image_src = warper(depth_src, image_dst) # NxCxHxW )rGrHrB)r;rCrdrGrHrB)rPrbrer6r6r7forward7szDepthWarper.forward)rDrET)__name__ __module__ __qualname____doc__rintstrboolrJ staticmethodr'r(rNrVr^rardrf __classcell__r6r6rQr7rs& $rT)rFrSrbrer3r4rBcCs$t||||d}|||||S)aFunction that warps a tensor from destination frame to reference given the depth in the reference frame. See :class:`~kornia.geometry.warp.DepthWarper` for details. Example: >>> # pinholes camera models >>> pinhole_dst = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4), ... torch.tensor([32]), torch.tensor([32])) >>> pinhole_src = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4), ... torch.tensor([32]), torch.tensor([32])) >>> # warp the destination frame to reference by depth >>> depth_src = torch.ones(1, 1, 32, 32) # Nx1xHxW >>> image_dst = torch.rand(1, 3, 32, 32) # NxCxHxW >>> image_src = depth_warp(pinhole_dst, pinhole_src, depth_src, image_dst, 32, 32) # NxCxHxW rA)rrV)rFrSrbrer3r4rBZwarperr6r6r7r[s r)F)F)F)T)$rjtypingrr'Ztorch.nnnnZtorch.nn.functionalZ functionalr;Zkornia.filters.sobelrZ kornia.utilsrZcamerarrrr r Z conversionsr Zlinalgr r rr__all__r(rmrrrModulerrkrr6r6r6r7sB     /0 B5