o oi@sddlmZddlmZmZmZddlZddlmZddlm Z m Z m Z ddl m Z ddlmZddlmZd d gZd1ddZd2d3ddZd4ddZd5d!d"Zd6d7d'd(Zd8d+d,ZGd-d d ZGd.d/d/eZGd0d d ZdS)9) annotations)OptionalTuplecastN)Size)Tensorstackzeros) validate_bbox)transform_points)eye_likeBoxesBoxes3Ddtype torch.dtypereturnboolcCs|tjtjtjtjtjfvSN)torchfloat16float32float64bfloat16half)rrI/home/ubuntu/.local/lib/python3.10/site-packages/kornia/geometry/boxes.py_is_floating_point_dtype!srpadboxeslist[torch.Tensor]methodstrtuple[torch.Tensor, list[int]]cstdd|Dstddd|Dd|dkr:tdd|Dfd d|D}tjjjj|d d }||fStd |d )z&Merge a list of boxes into one tensor.css8|]}|jddtddgko|dkVqdS)N)shaperrdim.0boxrrr 's6z"_merge_box_list..z5Input boxes must be a list of (N, 4, 2) shaped. Got: cSsg|]}|jqSrr'r)rrr (sz#_merge_box_list...rcss|]}|jdVqdS)rNr-r)rrrr,+scsg|] }|jdqS)rr-r)max_Nrrr.,sT) batch_first`z` is not implemented.) all TypeErrormaxrnnutilsrnn pad_sequenceNotImplementedError)rr statsoutputrr0r_merge_box_list%sr> torch.TensorMcCs|r|n|}|jdd\}}}|dkr|S|d|||}|jdkr*|n|d}|jd|jdkrJtd|jdd|jddt||}||}|S) aTransform 3D and 2D in kornia format by applying the transformation matrix M. Boxes and the transformation matrix could be batched or not. Args: boxes: 2D quadrilaterals or 3D hexahedrons in kornia format. M: the transformation matrix of shape :math:`(3, 3)` or :math:`(B, 3, 3)` for 2D and :math:`(4, 4)` or :math:`(B, 4, 4)` for 3D hexahedron. Nrr&zBatch size mismatch. Got z for boxes and z for the transformation matrix.) is_floating_pointfloatr'viewndim unsqueeze ValueErrorr view_as)rr@boxes_per_batchn_points_per_boxcoordinates_dimensionpointstransformed_boxesrrr_transform_boxes4s   rOxminyminwidthheightcCs|j|jkr|jkr|jkrdks tdtdt|jd|jdddf|j|jd}|d|d<|d|d <|d |d7<|d |d7<|d |d7<|d |d7<|S)Nr%zXWe expect to create a batch of 2D boxes (quadrilaterals) in vertices format (B, N, 4, 2)rr$devicerrB.r.rT.rTr.r%r.r%rT.r&rT)rFrHr r'rVrrG)rPrQrRrSpolygonsrrr_boxes_to_polygonsRs.&r^xyxyTmodevalidate_boxesc Cs|}|dr6|jdk}d|jkrdkr)nn|jddtddgks5td|d|jd n2|d ra|jdk}d|jkrKdkrTnn|jd dks`td |d|jd ntd ||rn|n|}|rv|n| d}|dr|dkr| }|ddddfd|ddddf<|ddddfd|ddddf<n|dkr| }ntd || pt |n}|d r;|dkr|d|d|d|d}}n0|dkr|d|dd|d|dd}}n|dkr |d|d}}ntd ||r*|dk rtd|dk r*td|d|d}}t ||||}ntd ||rI|}|S|d}|S)z%Convert from boxes to quadrilaterals.verticesr$r&r#Nr%z3Boxes shape must be (N, 4, 2) or (B, N, 4, 2) when z mode. Got r/xyrBz-Boxes shape must be (N, 4) or (B, N, 4) when Unknown mode r.rT vertices_plusr_.r&rX.r%rW xyxy_plusxywh%Some boxes have negative widths or 0.&Some boxes have negative heights or 0.)lower startswithrFr'rrrHrCrDrGcloner anyr^squeeze) rr`rabatchedquadrilateralsrSrRrPrQrrr_boxes_to_quadrilateralsdsX  6  ( $&   $,   rszmindepthc Cs0|j|jkr'|jkr'|jkr'|jkr'|jkr'dks,tdtdt|jd|jdddf|j|jd}|d|d <|d|d <|d|d <|d |d7<|d |d7<|d|d7<|d|d7<|}|d |dd7<tj ||gdd}|S)Nr%zUWe expect to create a batch of 3D boxes (hexahedrons) in vertices format (B, N, 8, 3)rrTr$r&rUrBrWrXrgrYrZr[r\r#r() rFrHr r'rVrrGrnrcat) rPrQrtrRrSrufront_vertices back_vertices polygons3drrr_boxes3d_to_polygons3ds F&r{c@sTeZdZdZ  dgdhd d ZdiddZdjddZedkddZdlddZ dmdnddZ dmdod#d$Z dpd'd(Z dpd)d*Z + + dqdrd/d0Zdsdtd2d3Z dqdud7d8Zdvd:d;Ze dwdxd>d?Z dydzdBdCZd{dGdHZdmd|dJdKZd}dLdMZd~ddQdRZedvdSdTZeddUdVZeddXdYZedd[d\ZdddadbZddcddZddedfZd+S)r a 2D boxes containing N or BxN boxes. Args: boxes: 2D boxes, shape of :math:`(N, 4, 2)`, :math:`(B, N, 4, 2)` or a list of :math:`(N, 4, 2)`. See below for more details. raise_if_not_floating_point: flag to control floating point casting behaviour when `boxes` is not a floating point tensor. True to raise an error when `boxes` isn't a floating point tensor, False to cast to float. mode: the box format of the input boxes. Note: **2D boxes format** is defined as a floating data type tensor of shape ``Nx4x2`` or ``BxNx4x2`` where each box is a `quadrilateral `_ defined by it's 4 vertices coordinates (A, B, C, D). Coordinates must be in ``x, y`` order. The height and width of a box is defined as ``width = xmax - xmin + 1`` and ``height = ymax - ymin + 1``. Examples of `quadrilaterals `_ are rectangles, rhombus and trapezoids. Trer!torch.Tensor | list[torch.Tensor]raise_if_not_floating_pointrr`r!rNonecCsd|_t|trt|\}|_t|tjstdt|d|s1|r-t d|j | }t |j dkr=|d}d|jkrHdkrSnn |j ddd ks\t d |j d|jdkrcd nd |_||_||_dS) N"Input boxes is not a Tensor. Got: r/+Coordinates must be in floating point. Got r)rBr$r&r$r#)r$r%z3Boxes shape must be (N, 4, 2) or (B, N, 4, 2). Got FT)_N isinstancelistr>rrr5typerCrHrrDlenr'reshaperF _is_batched_data_modeselfrr}r`rrr__init__s    , zBoxes.__init__keyslice | int | TensorcCs t||j|d}|j|_|SNF)rrrrrnew_boxrrr __getitem__zBoxes.__getitem__valuecC|j|j|<|Srrrrrrrr __setitem__ zBoxes.__setitem__tuple[int, ...] | SizecC|jjSrdatar'rrrrr'z Boxes.shape!tuple[torch.Tensor, torch.Tensor]cCs0ttj|jddd}|d|d}}||fS)aCompute boxes heights and widths. Returns: - Boxes heights, shape of :math:`(N,)` or :math:`(B,N)`. - Boxes widths, shape of :math:`(N,)` or :math:`(B,N)`. Example: >>> boxes_xyxy = torch.tensor([[[1,1,2,2],[1,1,3,2]]]) >>> boxes = Boxes.from_tensor(boxes_xyxy) >>> boxes.get_boxes_shape() (tensor([[1., 1.]]), tensor([[1., 2.]])) riTas_padded_sequencergrf)rrr to_tensor)r boxes_xywhwidthsheightsrrrget_boxes_shapeszBoxes.get_boxes_shapeFinplacecCs6tj|j|jgdd}|r||_|S|}||_|S)a"Merge boxes. Say, current instance holds :math:`(B, N, 4, 2)` and the incoming boxes holds :math:`(B, M, 4, 2)`, the merge results in :math:`(B, N + M, 4, 2)`. Args: boxes: 2D boxes. inplace: do transform in-place and return self. rTrv)rrwrrrn)rrrrobjrrrmerges z Boxes.mergeindices!tuple[Tensor, ...] | list[Tensor]valuesTensor | BoxescCsV|r|j}n|j}t|tr|||jn||||r"|S|}||_|Sr)rrnrr index_put_r)rrrrrrrrr index_put#s   zBoxes.index_put padding_sizercCst|jdkr|ddkstd|jd|jd|ddddfj|jjd 7<|jd |dddd fj|jjd 7<|S zMPad a bounding box. Args: padding_size: (B, 4) r%rTr$z%Expected padding_size as (B, 4). Got r/rW.NrVrXr&rr'size RuntimeErrorrtorVrrrrrr7 ,,z Boxes.padcCst|jdkr|ddkstd|jd|jd|ddddfj|jjd 8<|jd |dddd fj|jjd 8<|SrrrrrrunpadDrz Boxes.unpadNtopleft"Optional[Tensor | tuple[int, int]]botrightc Cs`t|tr t|ts t|r|j}n|j}|dddddfd|dd}||d|k|d|d|k<|dddddfd|dd}||d|k|d|d|k<|dddddfd|dd}||d|k|d|d|k<|dddddfd|dd}||d|k|d|d|k<|r|S|} || _| S)NrTr$rWrX)rrr;rrnrepeatr) rrrrr topleft_x topleft_y botright_x botright_yrrrrclampQs$ & & & & z Boxes.clampcorrespondence_preservecCst)aTrim out zero padded boxes. Given box arrangements of shape :math:`(4, 4, Box)`: == === == === == === == === == -- Box -- Box -- Box -- Box -- -- 0 -- 0 -- Box -- Box -- -- 0 -- Box -- 0 -- 0 -- -- 0 -- 0 -- 0 -- 0 -- == === == === == === == === == Nothing will change if correspondence_preserve is True. Only pure zero layers will be removed, resulting in shape :math:`(4, 3, Box)`: == === == === == === == === == -- Box -- Box -- Box -- Box -- -- 0 -- 0 -- Box -- Box -- -- 0 -- Box -- 0 -- 0 -- == === == === == === == === == Otherwise, you will get :math:`(4, 2, Box)`: == === == === == === == === == -- Box -- Box -- Box -- Box -- -- 0 -- Box -- Box -- Box -- == === == === == === == === == )r;)rrrrrrtrimosz Boxes.trimmin_areaOptional[float]max_areacCs`|}|r |j}n|j}|durd|||k<|dur#d|||k<|r'|S|}||_|S)Ng) compute_arearrn)rrrrarearrrrrfilter_boxes_by_areas   zBoxes.filter_boxes_by_arear?c Cs|jjdkr |jdn|j}|jddd}t|d|d|d|d}tj|ddd\}}t|d|d  d d d }|d|d}}d t tj |t |dd|t |dddd } |jjdkrw| |jj d d S| S)zReturn :math:`(B, N)`.r$)rBr$r%rTT)r(keepdimrXrW)r( descendingrBr%g?rvN)rrFrEmeanratan2sortgatherrGexpandabssumrollr') rcoordscentroidangles_clockwise_indicesordered_cornersxyrrrrrs$8&zBoxes.compute_arear_racs<t|tjrt|d}n fdd|D}||dS)ab Create :class:`Boxes` from boxes stored in another format. Args: boxes: 2D boxes, shape of :math:`(N, 4)`, :math:`(B, N, 4)`, :math:`(N, 4, 2)` or :math:`(B, N, 4, 2)`. mode: The format in which the boxes are provided. * 'xyxy': boxes are assumed to be in the format ``xmin, ymin, xmax, ymax`` where ``width = xmax - xmin`` and ``height = ymax - ymin``. With shape :math:`(N, 4)`, :math:`(B, N, 4)`. * 'xyxy_plus': similar to 'xyxy' mode but where box width and length are defined as ``width = xmax - xmin + 1`` and ``height = ymax - ymin + 1``. With shape :math:`(N, 4)`, :math:`(B, N, 4)`. * 'xywh': boxes are assumed to be in the format ``xmin, ymin, width, height`` where ``width = xmax - xmin`` and ``height = ymax - ymin``. With shape :math:`(N, 4)`, :math:`(B, N, 4)`. * 'vertices': boxes are defined by their vertices points in the following ``clockwise`` order: *top-left, top-right, bottom-right, bottom-left*. Vertices coordinates are in (x,y) order. Finally, box width and height are defined as ``width = xmax - xmin`` and ``height = ymax - ymin``. With shape :math:`(N, 4, 2)` or :math:`(B, N, 4, 2)`. * 'vertices_plus': similar to 'vertices' mode but where box width and length are defined as ``width = xmax - xmin + 1`` and ``height = ymax - ymin + 1``. ymin + 1``. With shape :math:`(N, 4, 2)` or :math:`(B, N, 4, 2)`. validate_boxes: check if boxes are valid rectangles or not. Valid rectangles are those with width and height >= 1 (>= 2 when mode ends with '_plus' suffix). Returns: :class:`Boxes` class containing the original `boxes` in the format specified by ``mode``. Examples: >>> boxes_xyxy = torch.as_tensor([[0, 3, 1, 4], [5, 1, 8, 4]]) >>> boxes = Boxes.from_tensor(boxes_xyxy, mode='xyxy') >>> boxes.data # (2, 4, 2) tensor([[[0., 3.], [0., 3.], [0., 3.], [0., 3.]], [[5., 1.], [7., 1.], [7., 3.], [5., 3.]]]) r`racsg|]}t|qSr)rsr)rrrr.sz%Boxes.from_tensor..F)rrrrs)clsrr`rarrrrr from_tensors / zBoxes.from_tensor Optional[str]rcCsR|jr|jn|jd}tj|jdd|jddgdd|jd|jdd}|dur/|j }| }|dvr8n)|dvrZ|d |d d|d |d d}}||d <||d <nt d ||dvrutj gd|j |jd}||}|drt|d |d |d |d }|jdur|sddt||jD}|S|jr|n|d}|S)auCast :class:`Boxes` to a tensor. ``mode`` controls which 2D boxes format should be use to represent boxes in the tensor. Args: mode: the output box format. It could be: * 'xyxy': boxes are defined as ``xmin, ymin, xmax, ymax`` where ``width = xmax - xmin`` and ``height = ymax - ymin``. * 'xyxy_plus': similar to 'xyxy' mode but where box width and length are defined as ``width = xmax - xmin + 1`` and ``height = ymax - ymin + 1``. * 'xywh': boxes are defined as ``xmin, ymin, width, height`` where ``width = xmax - xmin`` and ``height = ymax - ymin``. * 'vertices': boxes are defined by their vertices points in the following ``clockwise`` order: *top-left, top-right, bottom-right, bottom-left*. Vertices coordinates are in (x,y) order. Finally, box width and height are defined as ``width = xmax - xmin`` and ``height = ymax - ymin``. * 'vertices_plus': similar to 'vertices' mode but where box width and length are defined as ``width = xmax - xmin + 1`` and ``height = ymax - ymin + 1``. ymin + 1``. as_padded_sequence: whether to keep the pads for a list of boxes. This parameter is only valid if the boxes are from a box list whilst `from_tensor`. Returns: Boxes tensor in the ``mode`` format. The shape depends with the ``mode`` value: * 'vertices' or 'verticies_plus': :math:`(N, 4, 2)` or :math:`(B, N, 4, 2)`. * Any other value: :math:`(N, 4)` or :math:`(B, N, 4)`. Examples: >>> boxes_xyxy = torch.as_tensor([[0, 3, 1, 4], [5, 1, 8, 4]]) >>> boxes = Boxes.from_tensor(boxes_xyxy) >>> assert (boxes_xyxy == boxes.to_tensor(mode='xyxy')).all() rr#rvrTr$N)r_rh)rirbrerfrXrgrWrd)r_rb)rrrTrTrUrbcSs<g|]\}}tjj|t|jdddgd| gqS)rTr)rr7 functionalrrr')r*onrrrr.)s<z#Boxes.to_tensor..)rrrGrraminamaxrEr'r`rlrH as_tensorrVrrmr^rziprp)rr`r batched_boxesrrSrRoffsetrrrrs0$"*  zBoxes.to_tensorrSintrRcCs|jjrtd|j}|j}|j}|jdkr|jr0tj|jj d|jj d||f|j|jd}ntj|jj d||f|j|jd}t tj |j ddd}|d d d d f d||d dd d f d|t|d |||d d D]\}} d|| d| d| d| d f<qx|S|r|j d|j d||f} n|j d||f} t t |j ddd}|d d d d f d||d dd d f d||d d } | d d df| d d df| d d d f| d d dff\} } }}| d|} |d|}| d|} |d|}tj||d}tj||d}|d d d f| d d d fk|d d d f|d d d fdk@}|d d d f| d d d fk|d d d f|d d d fdk@}|d |d@|}|j| S)aConvert 2D boxes to masks. Covered area is 1 and the remaining is 0. Args: height: height of the masked image/images. width: width of the masked image/images. Returns: the output mask tensor, shape of :math:`(N, width, height)` or :math:`(B,N, width, height)` and dtype of :func:`Boxes.dtype` (it can be any floating point dtype). Note: It is currently non-differentiable. Examples: >>> boxes = Boxes(torch.tensor([[ # Equivalent to boxes = Boxes.from_tensor([[1,1,4,3]]) ... [1., 1.], ... [4., 1.], ... [4., 3.], ... [1., 3.], ... ]])) # 1x4x2 >>> boxes.to_mask(5, 5) tensor([[[0., 0., 0., 0., 0.], [0., 1., 1., 1., 1.], [0., 1., 1., 1., 1.], [0., 1., 1., 1., 1.], [0., 0., 0., 0., 0.]]]) cBoxes.to_tensor isn't differentiable. Please, create boxes from tensors with `requires_grad=False`.cudarrTrrVr_Tr.Nr%rBr$r&r)r requires_gradrrrrVrrr r'rrrclamp_rrEroundrlongrarangerGr)rrSrR is_batchedrrVmaskclipped_boxes_xyxy mask_channelbox_xyxy out_shaper_x1y1x2y2ysxsy_maskx_maskmasksrrrto_mask.sN "" &D    DD z Boxes.to_maskr@cCsjd|jkr dkrnn |jdddkrtd|jdt|j|}|r,||_|S|}||_|S)aApply a transformation matrix to the 2D boxes. Args: M: The transformation matrix to be applied, shape of :math:`(3, 3)` or :math:`(B, 3, 3)`. inplace: do transform in-place and return self. Returns: The transformed boxes. r%r&r#N)r&r&zAThe transformation matrix shape must be (3, 3) or (B, 3, 3). Got r/)rFr'rHrOrrn)rr@rrNrrrrtransform_boxess,  zBoxes.transform_boxescC|j|ddS)z1Inplace version of :func:`Boxes.transform_boxes`.Trrrr@rrrtransform_boxes_zBoxes.transform_boxes_warprr cCsH|dkrt|dkr nttd|}||dddddf<|j||dS)a#Translate boxes by the provided size. Args: size: translate size for x, y direction, shape of :math:`(B, 2)`. method: "warp" or "fast". inplace: do transform in-place and return self. Returns: The transformed boxes. fastr r&Nr%r)r;r r)rrr rr@rrr translates  zBoxes.translatecC|jSrrrrrrrz Boxes.datacCrrrrrrrr`rz Boxes.mode torch.devicecCrzReturns boxes device.rrVrrrrrVz Boxes.devicercCrzReturns boxes dtype.rrrrrrrrz Boxes.dtyperVOptional[torch.device]rOptional[torch.dtype]cC.|dur t|s td|jj||d|_|Sz)Like :func:`torch.nn.Module.to()` method.NzBoxes must be in floating pointrUrrHrrrrVrrrrrzBoxes.tocCs0t||jd}|j|_|j|_|j|_|Sr)rrrnrrrrrrrrrns z Boxes.clonecCs|j||_|Sr)rr)rrrrrrsz Boxes.type)Tre)rr|r}rr`r!rr~)rrrr )rrrr rr rr)rrF)rr rrrr )rrrrrrrr )rrrr )NNF)rrrrrrrr )FF)rrrrrr )rrrrrrrr rr?r_T)rr|r`r!rarrr r)r`rrrrr|)rSrrRrrr?)r@r?rrrr )r@r?rr )r F)rrr r!rrrr rr!rrrrNN)rVrrrrr )rr )rrrr ) __name__ __module__ __qualname____doc__rrrpropertyr'rrrrrrrrr classmethodrrrrr r rr`rVrrrnrrrrrr sV         6 H ^        csFeZdZUded<e ddd d Zddfdd ZdddZZS) VideoBoxesrtemporal_channel_sizeTrr|rarrc Cst|tfs|dks|jddtddgkrtd|d}t| |d|dd|d |dd |d }||d d }||_ |S) Nr#r$r%zQInput box type is not yet supported. Please input an `BxTxNx4x2` tensor directly.rTrrBr&rerF) rrr(r'rrrHrrsrEr.)rrrar.rroutrrrrs4 * zVideoBoxes.from_tensorNr`rcsLtj|dd}t|tr|jdjg|jddRSfdd|DS)NFrrBrTcs,g|]}|jdjg|jddRqS)rBrTN)rEr.r')r*_outrrrr.s,z(VideoBoxes.to_tensor..)superrrrrEr.r')rr`r0 __class__rrrs  zVideoBoxes.to_tensorcCs8t||jd}|j|_|j|_|j|_|j|_|Sr)rrrnrrrr.rrrrrns zVideoBoxes.clone)T)rr|rarrr-r)r`rrr|)rr-) r'r(r)__annotations__r,rrrn __classcell__rrr3rr-s r-c@seZdZdZ d?d@d d ZdAddZdBddZedCddZdDddZ e dEdFddZ dGdHdd Z dId%d&Z dJdKd*d+ZdLd,d-ZedMd.d/ZedNd0d1ZedOd3d4ZedPd6d7ZdQdRd=d>Zd8S)Sra3D boxes containing N or BxN boxes. Args: boxes: 3D boxes, shape of :math:`(N,8,3)` or :math:`(B,N,8,3)`. See below for more details. raise_if_not_floating_point: flag to control floating point casting behaviour when `boxes` is not a floating point tensor. True to raise an error when `boxes` isn't a floating point tensor, False to cast to float. Note: **3D boxes format** is defined as a floating data type tensor of shape ``Nx8x3`` or ``BxNx8x3`` where each box is a `hexahedron `_ defined by it's 8 vertices coordinates. Coordinates must be in ``x, y, z`` order. The height, width and depth of a box is defined as ``width = xmax - xmin + 1``, ``height = ymax - ymin + 1`` and ``depth = zmax - zmin + 1``. Examples of `hexahedrons `_ are cubes and rhombohedrons. T xyzxyz_plusrr?r}rr`r!rr~cCst|tjstdt|d|s#|rtd|jd|}t |j dkr/| d}d|j kr:dkrEnn |j ddd ksNtd |j d|j dkrUd nd |_ ||_||_dS) Nrr/rr)rBr&r$r#)r&z53D bbox shape must be (N, 8, 3) or (B, N, 8, 3). Got FT)rrrr5rrCrHrrDrr'rrFrrrrrrrrs  , zBoxes3D.__init__rrcCs t|j|ddd}|j|_|S)NFr7r`)rrrrrrrr1rzBoxes3D.__getitem__rcCrrrrrrrr6rzBoxes3D.__setitem__rcCrrrrrrrr':rz Boxes3D.shape/tuple[torch.Tensor, torch.Tensor, torch.Tensor]cCs2|jdd}|d|d|d}}}|||fS)a*Compute boxes heights and widths. Returns: - Boxes depths, shape of :math:`(N,)` or :math:`(B,N)`. - Boxes heights, shape of :math:`(N,)` or :math:`(B,N)`. - Boxes widths, shape of :math:`(N,)` or :math:`(B,N)`. Example: >>> boxes_xyzxyz = torch.tensor([[ 0, 1, 2, 10, 21, 32], [3, 4, 5, 43, 54, 65]]) >>> boxes3d = Boxes3D.from_tensor(boxes_xyzxyz) >>> boxes3d.get_boxes_shape() (tensor([30., 60.]), tensor([20., 50.]), tensor([10., 40.])) xyzwhdr:rf.r$.r/)r)r boxes_xyzwhdrrdepthsrrrr>s  zBoxes3D.get_boxes_shapexyzxyzrac Csd|jkr dkrnn|jddkstd|jd|jdk}|r&|n|d}|r1|n|}|d|d |d }}}|}|d krd|d |d}|d |d } |d|d } n=|dkr|d |dd}|d |d d} |d|d d} n|dkr|d |d |d} } }ntd||r|dkrtd| dkrtd| dkrtdt||||| | } |r| n| d} || d|dS)aCreate :class:`Boxes3D` from 3D boxes stored in another format. Args: boxes: 3D boxes, shape of :math:`(N,6)` or :math:`(B,N,6)`. mode: The format in which the 3D boxes are provided. * 'xyzxyz': boxes are assumed to be in the format ``xmin, ymin, zmin, xmax, ymax, zmax`` where ``width = xmax - xmin``, ``height = ymax - ymin`` and ``depth = zmax - zmin``. * 'xyzxyz_plus': similar to 'xyzxyz' mode but where box width, length and depth are defined as ``width = xmax - xmin + 1``, ``height = ymax - ymin + 1`` and ``depth = zmax - zmin + 1``. * 'xyzwhd': boxes are assumed to be in the format ``xmin, ymin, zmin, width, height, depth`` where ``width = xmax - xmin``, ``height = ymax - ymin`` and ``depth = zmax - zmin``. validate_boxes: check if boxes are valid rectangles or not. Valid rectangles are those with width, height and depth >= 1 (>= 2 when mode ends with '_plus' suffix). Returns: :class:`Boxes3D` class containing the original `boxes` in the format specified by ``mode``. Examples: >>> boxes_xyzxyz = torch.as_tensor([[0, 3, 6, 1, 4, 8], [5, 1, 3, 8, 4, 9]]) >>> boxes = Boxes3D.from_tensor(boxes_xyzxyz, mode='xyzxyz') >>> boxes.data # (2, 8, 3) tensor([[[0., 3., 6.], [0., 3., 6.], [0., 3., 6.], [0., 3., 6.], [0., 3., 7.], [0., 3., 7.], [0., 3., 7.], [0., 3., 7.]], [[5., 1., 3.], [7., 1., 3.], [7., 3., 3.], [5., 3., 3.], [5., 1., 8.], [7., 1., 8.], [7., 3., 8.], [5., 3., 8.]]]) r%r&rBr8z,BBox shape must be (N, 6) or (B, N, 6). Got r/rrWrXrgrArfr=r>r7rTr<rdrjrkz%Some boxes have negative depths or 0.F)r}r`) rFr'rHrGrCrDrlror{rp) rrr`rarqrPrQrtrRrSru hexahedronsrrrrQs8(,    zBoxes3D.from_tensorc Cst|jjrtd|jr|jn|jd}t|jdd|jddgdd|j d|j dd}| }|dvr8n6|dvrg|d |d d}|d |d d}|d |dd}||d <||d <||d <nt d||dvrt j gd|j|jd}||}|dr|d |d |d}} } |d |d |d }}}t|| | |||}|jr|}|S|d}|S)aCast :class:`Boxes3D` to a tensor. ``mode`` controls which 3D boxes format should be use to represent boxes in the tensor. Args: mode: The format in which the boxes are provided. * 'xyzxyz': boxes are assumed to be in the format ``xmin, ymin, zmin, xmax, ymax, zmax`` where ``width = xmax - xmin``, ``height = ymax - ymin`` and ``depth = zmax - zmin``. * 'xyzxyz_plus': similar to 'xyzxyz' mode but where box width, length and depth are defined as ``width = xmax - xmin + 1``, ``height = ymax - ymin + 1`` and ``depth = zmax - zmin + 1``. * 'xyzwhd': boxes are assumed to be in the format ``xmin, ymin, zmin, width, height, depth`` where ``width = xmax - xmin``, ``height = ymax - ymin`` and ``depth = zmax - zmin``. * 'vertices': boxes are defined by their vertices points in the following ``clockwise`` order: *front-top-left, front-top-right, front-bottom-right, front-bottom-left, back-top-left, back-top-right, back-bottom-right, back-bottom-left*. Vertices coordinates are in (x,y, z) order. Finally, box width, height and depth are defined as ``width = xmax - xmin``, ``height = ymax - ymin`` and ``depth = zmax - zmin``. * 'vertices_plus': similar to 'vertices' mode but where box width, length and depth are defined as ``width = xmax - xmin + 1`` and ``height = ymax - ymin + 1``. Returns: 3D Boxes tensor in the ``mode`` format. The shape depends with the ``mode`` value: * 'vertices' or 'verticies_plus': :math:`(N, 8, 3)` or :math:`(B, N, 8, 3)`. * Any other value: :math:`(N, 6)` or :math:`(B, N, 6)`. Note: It is currently non-differentiable due to a bug. See github issue `#1304 `_. Examples: >>> boxes_xyzxyz = torch.as_tensor([[0, 3, 6, 1, 4, 8], [5, 1, 3, 8, 4, 9]]) >>> boxes = Boxes3D.from_tensor(boxes_xyzxyz, mode='xyzxyz') >>> assert (boxes.to_tensor(mode='xyzxyz') == boxes_xyzxyz).all() aBoxes3D.to_tensor doesn't support computing gradients since they aren't accurate. Please, create boxes from tensors with `requires_grad=False`. This is a known bug. Help is needed to fix it. For more information, see https://github.com/kornia/kornia/issues/1396.rr#rvrTr8)rAr7)r<rbrerfrWr=rXr>rgrd)rArb)rrrrTrTrTrUrb)rrrrrGrrrrEr'rlrHrrrVrrmr{rp) rr`rrrRrSrurrPrQrtrrrrs<&     zBoxes3D.to_tensorrurrSrRcCs,|jjrtd|jr$t|jjd|jjd|||f|jj|jjd}nt|jjd|||f|jj|jjd}|d}|ddddf d||ddddf d||dd ddf d|t | d |||| d d  D]\}}d||d |d |d|d |d|df<qv|S)uConvert ·D boxes to masks. Covered area is 1 and the remaining is 0. Args: depth: depth of the masked image/images. height: height of the masked image/images. width: width of the masked image/images. Returns: the output mask tensor, shape of :math:`(N, depth, width, height)` or :math:`(B,N, depth, width, height)` and dtype of :func:`Boxes3D.dtype` (it can be any floating point dtype). Note: It is currently non-differentiable. Examples: >>> boxes = Boxes3D(torch.tensor([[ # Equivalent to boxes = Boxes.3Dfrom_tensor([[1,1,1,3,3,2]]) ... [1., 1., 1.], ... [3., 1., 1.], ... [3., 3., 1.], ... [1., 3., 1.], ... [1., 1., 2.], ... [3., 1., 2.], ... [3., 3., 2.], ... [1., 3., 2.], ... ]])) # 1x8x3 >>> boxes.to_mask(4, 5, 5) tensor([[[[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]], [[0., 0., 0., 0., 0.], [0., 1., 1., 1., 0.], [0., 1., 1., 1., 0.], [0., 1., 1., 1., 0.], [0., 0., 0., 0., 0.]], [[0., 0., 0., 0., 0.], [0., 1., 1., 1., 0.], [0., 1., 1., 1., 0.], [0., 1., 1., 1., 0.], [0., 0., 0., 0., 0.]], [[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]]]) rrrTrrA.Nr&r%rBr8r/r$)rrrrr r'rrVrrrrErr)rrurSrRrclipped_boxes_xyzxyzr box_xyzxyzrrrrs.4&   ,zBoxes3D.to_maskFr@rcCsdd|jkr dkrnn |jdddkrtd|jdt|j|}|r,||_|St|dd S) aApply a transformation matrix to the 3D boxes. Args: M: The transformation matrix to be applied, shape of :math:`(4, 4)` or :math:`(B, 4, 4)`. inplace: do transform in-place and return self. Returns: The transformed boxes. r%r&r#N)r$r$zAThe transformation matrix shape must be (4, 4) or (B, 4, 4). Got r/Fr7)rFr'rHrOrr)rr@rrNrrrrBs,   zBoxes3D.transform_boxescCr)z3Inplace version of :func:`Boxes3D.transform_boxes`.Trrrrrrr Wr zBoxes3D.transform_boxes_cCrrrrrrrr[rz Boxes3D.datacCrrrrrrrr`_rz Boxes3D.modercCrrrrrrrrVcrzBoxes3D.devicercCrrrrrrrrhrz Boxes3D.dtypeNrVrrrcCrrrrrrrrmrz Boxes3D.to)Tr7)rr?r}rr`r!rr~)rrrr)rrrrrrr)rr;)rAT)rr?r`r!rarrr)rA)r`r!rr?)rurrSrrRrrr?r )r@r?rrrr)r@r?rrr!r#r$r%r&)rVrrrrr)r'r(r)r*rrrr+r'rr,rrrrr rr`rVrrrrrrr s0     M O T     )rrrr)r)rrr r!rr")rr?r@r?rr?) rPr?rQr?rRr?rSr?rr?r")rr?r`r!rarrr?)rPr?rQr?rtr?rRr?rSr?rur?rr?) __future__rtypingrrrrr kornia.corerrr kornia.geometry.bboxr kornia.geometry.linalgr kornia.utilsr __all__rr>rOr^rsr{r r-rrrrrs,           :+%