EipSSKrSSKrSSKrSSKJr SSKJrJrJrJ r J r SSK r SSK r SSKJrJr SSKJr SSKJr SSKJrJrJr SSKJr S S KJr S S KJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r, "S S \5r-"SS\5r."SS\5r/"SS\5r0"SS\5r1"SS\5r2"SS\5r3"SS\5r4"SS\5r5"SS\5r6"S S!\5r7"S"S#\5r8"S$S%\5r9"S&S'\5r:"S(S)\5r;"S*S+\5r<"S,S-\5r="S.S/\5r>g)0N)Sequence)AnyCallableLiteralOptionalUnion) transforms tv_tensors)box_iou)_get_perspective_coeffs) functionalInterpolationMode Transform) _FillType)_RandomApplyTransform) _check_padding_arg_check_padding_mode_arg_check_sequence_input _get_fill _setup_angle_setup_fill_arg_setup_number_or_seq _setup_sizeget_bounding_boxeshas_allhas_anyis_pure_tensor query_sizecP\rSrSrSr\R rS\S\ \ \4S\4Sjr Sr g) RandomHorizontalFlip"aHorizontally flip the input with a given probability. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: p (float, optional): probability of the input being flipped. Default value is 0.5 inptparamsreturncBUR[RU5$N) _call_kernelFhorizontal_flipselfr#r$s `/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torchvision/transforms/v2/_geometry.py transformRandomHorizontalFlip.transform0s  !2!2D99N) __name__ __module__ __qualname____firstlineno____doc__ _transformsr!_v1_transform_clsrdictstrr.__static_attributes__r1r0r-r!r!"s7 $88:c:4S>:c:r0r!cP\rSrSrSr\R rS\S\ \ \4S\4Sjr Sr g) RandomVerticalFlip4aVertically flip the input with a given probability. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: p (float, optional): probability of the input being flipped. Default value is 0.5 r#r$r%cBUR[RU5$r')r(r) vertical_flipr+s r-r.RandomVerticalFlip.transformBs  $77r0r1N) r2r3r4r5r6r7r=r8rr9r:r.r;r1r0r-r=r=4s7 $668c84S>8c8r0r=c ^\rSrSrSr\R r\RSS4S\ \ \ \ S4S\ \\ 4S\ \ S\ \S S4 U4S jjjrS \S \\\4S \4S jrSrU=r$)ResizeFa) Resize the input to the given size. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: size (sequence, int, or None): Desired output size. - If size is a sequence like (h, w), output size will be matched to this. - If size is an int, smaller edge of the image will be matched to this number. i.e, if height > width, then image will be rescaled to (size * height / width, size). - If size is None, the output shape is determined by the ``max_size`` parameter. .. note:: In torchscript mode size as single int is not supported, use a sequence of length 1: ``[size, ]``. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.NEAREST_EXACT``, ``InterpolationMode.BILINEAR`` and ``InterpolationMode.BICUBIC`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. max_size (int, optional): The maximum allowed for the longer edge of the resized image. - If ``size`` is an int: if the longer edge of the image is greater than ``max_size`` after being resized according to ``size``, ``size`` will be overruled so that the longer edge is equal to ``max_size``. As a result, the smaller edge may be shorter than ``size``. This is only supported if ``size`` is an int (or a sequence of length 1 in torchscript mode). - If ``size`` is None: the longer edge of the image will be matched to max_size. i.e, if height > width, then image will be rescaled to (max_size, max_size * width / height). This should be left to ``None`` (default) when ``size`` is a sequence. antialias (bool, optional): Whether to apply antialiasing. It only affects **tensors** with bilinear or bicubic modes and it is ignored otherwise: on PIL images, antialiasing is always applied on bilinear or bicubic modes; on other modes (for PIL images and tensors), antialiasing makes no sense and this parameter is ignored. Possible values are: - ``True`` (default): will apply antialiasing for bilinear or bicubic modes. Other mode aren't affected. This is probably what you want to use. - ``False``: will not apply antialiasing for tensors on any mode. PIL images are still antialiased on bilinear or bicubic modes, because PIL doesn't support no antialias. - ``None``: equivalent to ``False`` for tensors and ``True`` for PIL images. This value exists for legacy reasons and you probably don't want to use it unless you really know what you are doing. The default value changed from ``None`` to ``True`` in v0.17, for the PIL and Tensor backends to be consistent. NTsize interpolationmax_size antialiasr%cR>[TU]5 [U[5(aU/nOg[U[5(a[ U5S;a [ U5nO7Uc%[U[5(d[SUS35eO[SUS35eXlX l X0l X@l g)N>rz7max_size must be an integer when size is None, but got z instead.zLsize can be an integer, a sequence of one or two integers, or None, but got ) super__init__ isinstanceintrlenlist ValueErrorrErFrGrH)r,rErFrGrH __class__s r-rLResize.__init__s  dC 6D h ' 'CI,?:D \h,, #Z[cZddm!noo-^_c^ddmn  * "r0r#r$c UR[RUURURUR UR S9$)N)rFrGrH)r(r)resizerErFrGrHr+s r-r.Resize.transformsB  HH  II,,]]nn !  r0)rHrFrGrE)r2r3r4r5r6r7rCr8rBILINEARrrNrrboolrLrr9r:r.r; __classcell__rRs@r-rCrCFs;z$** 8I7Q7Q"&$( #C#,-#.34#3- # D> #  ##4 c 4S> c  r0rCc|^\rSrSrSr\R rS\\ \ \ 44U4Sjjr S\ S\ \\ 4S\ 4SjrS rU=r$) CenterCropaCrop the input at the center. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. If image size is smaller than output size along any edge, image is padded with 0 and then center cropped. Args: size (sequence or int): Desired output size of the crop. If size is an int instead of sequence like (h, w), a square crop (size, size) is made. If provided a sequence of length 1, it will be interpreted as (size[0], size[0]). rEc@>[TU]5 [USS9UlgN3Please provide only two dimensions (h, w) for size. error_msgrKrLrrEr,rErRs r-rLCenterCrop.__init__ 0ef r0r#r$r%cRUR[RXRS9$)N) output_size)r(r) center_croprEr+s r-r.CenterCrop.transforms   )) LLr0rE)r2r3r4r5r6r7r\r8rrNrrLrr9r:r.r;rYrZs@r-r\r\s^ $..gU3 #56gMcM4S>McMMr0r\c ^\rSrSrSr\R rSS\RS4S\ \ \ \ 4S\ \\4S\ \\4S \ \\ 4S \\S S 4 U4S jjjrS\\S \\\44SjrS\S\\\4S \4SjrSrU=r$)RandomResizedCropa Crop a random portion of the input and resize it to a given size. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. A crop of the original input is made: the crop has a random area (H * W) and a random aspect ratio. This crop is finally resized to the given size. This is popularly used to train the Inception networks. Args: size (int or sequence): expected output size of the crop, for each edge. If size is an int instead of sequence like (h, w), a square output size ``(size, size)`` is made. If provided a sequence of length 1, it will be interpreted as (size[0], size[0]). .. note:: In torchscript mode size as single int is not supported, use a sequence of length 1: ``[size, ]``. scale (tuple of float, optional): Specifies the lower and upper bounds for the random area of the crop, before resizing. The scale is defined with respect to the area of the original image. ratio (tuple of float, optional): lower and upper bounds for the random aspect ratio of the crop, before resizing. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.NEAREST_EXACT``, ``InterpolationMode.BILINEAR`` and ``InterpolationMode.BICUBIC`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. antialias (bool, optional): Whether to apply antialiasing. It only affects **tensors** with bilinear or bicubic modes and it is ignored otherwise: on PIL images, antialiasing is always applied on bilinear or bicubic modes; on other modes (for PIL images and tensors), antialiasing makes no sense and this parameter is ignored. Possible values are: - ``True`` (default): will apply antialiasing for bilinear or bicubic modes. Other mode aren't affected. This is probably what you want to use. - ``False``: will not apply antialiasing for tensors on any mode. PIL images are still antialiased on bilinear or bicubic modes, because PIL doesn't support no antialias. - ``None``: equivalent to ``False`` for tensors and ``True`` for PIL images. This value exists for legacy reasons and you probably don't want to use it unless you really know what you are doing. The default value changed from ``None`` to ``True`` in v0.17, for the PIL and Tensor backends to be consistent. )g{Gz??)g?gUUUUUU?TrEscaleratiorFrHr%Nc>[TU]5 [USS9Ul[ U[ 5(a[ U5S:wa [S5e[ U[ 5(a[ U5S:wa [S5eUSUS:d USUS:a[R"S5 X l X0l X@l XPl [R"[R "UR55Ulg) Nr`rarJz)Scale should be a sequence of two floats.z)Ratio should be a sequence of two floats.rrz,Scale and ratio should be of kind (min, max))rKrLrrErMrrO TypeErrorwarningswarnrprqrFrHtorchlogtensor _log_ratio)r,rErprqrFrHrRs r-rLRandomResizedCrop.__init__s 0ef %**c%jAoGH H%**c%jAoGH H !HuQx U1Xa%8 MMH I  *"))ELL$<=r0 flat_inputsc [U5up#X#-nURn[S5GHrnU[R"S5R UR SUR S5R5-n[R"[R"S5R USUS55R5n[[[R"Xx-555n [[[R"Xx- 555n SU s=:a U::dGMO GM SU s=:a U::dGMO GM![R"SX*- S-SS9R5n [R"SX9- S-SS9R5n O [U5[U5- n U [UR 5:a-Un [[U [UR 5- 55n OJU [#UR 5:a-Un [[U [#UR 5-55n OUn Un X*- S-n X9- S-n [%XXS9$)N rrrrkrJtopleftheightwidth)rryrangervemptyuniform_rpitemexprNroundmathsqrtrandintfloatminrqmaxr9)r,r{rrarea log_ratio_ target_area aspect_ratiowhijin_ratios r- make_paramsRandomResizedCrop.make_paramss";/ ~OO rAQ!8!8A ST !V![![!]]K 99 A''aLaL df E$))K$>?@AAE$))K$>?@AA1~~~!a/6//MM!VZ!^$?DDFMM!UY]>CCE$U|eFm3H#djj/)a#djj/123C O+a#djj/123!Aq A!55r0r#r$cUR"[RU40UDURURUR S.D6$)NrErFrH)r(r) resized_croprErFrHr+s r-r.RandomResizedCrop.transform6sC  NND $* 15$J\J\hlhvhv  r0)ryrHrFrqrprE)r2r3r4r5r6r7rmr8rrWrrNrtuplerrrXrLrPrr9r:rr.r;rYrZs@r-rmrms-^$55 &1%;7H7Q7Q$( >C#&'>UE\">UE\" > .34 > D> > >>2$6tCy$6T#s(^$6L c 4S> c  r0rmc ^\rSrSrSr\R rS\\ \ \ 4SS4U4Sjjr S\ S\ S \ S \ S\ 4 U4S jjrS\ S \\\ 4S\ 4S jrS\\ SS4SjrSrU=r$)FiveCropi<ayCrop the image or video into four corners and the central crop. If the input is a :class:`torch.Tensor` or a :class:`~torchvision.tv_tensors.Image` or a :class:`~torchvision.tv_tensors.Video` it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. .. Note:: This transform returns a tuple of images and there may be a mismatch in the number of inputs and targets your Dataset returns. See below for an example of how to deal with this. Args: size (sequence or int): Desired output size of the crop. If size is an ``int`` instead of sequence like (h, w), a square crop of size (size, size) is made. If provided a sequence of length 1, it will be interpreted as (size[0], size[0]). Example: >>> class BatchMultiCrop(transforms.Transform): ... def forward(self, sample: Tuple[Tuple[Union[tv_tensors.Image, tv_tensors.Video], ...], int]): ... images_or_videos, labels = sample ... batch_size = len(images_or_videos) ... image_or_video = images_or_videos[0] ... images_or_videos = tv_tensors.wrap(torch.stack(images_or_videos), like=image_or_video) ... labels = torch.full((batch_size,), label, device=images_or_videos.device) ... return images_or_videos, labels ... >>> image = tv_tensors.Image(torch.rand(3, 256, 256)) >>> label = 3 >>> transform = transforms.Compose([transforms.FiveCrop(224), BatchMultiCrop()]) >>> images, labels = transform(image, label) >>> images.shape torch.Size([5, 3, 224, 224]) >>> labels tensor([3, 3, 3, 3, 3]) rEr%Nc@>[TU]5 [USS9Ulgr_rcrds r-rLFiveCrop.__init__crfr0r r#argskwargsc,>[U[R[R[R45(aB[ R "[U5RS[U5RS35 [TU]("X/UQ70UD6$Nz:() is currently passing through inputs of type tv_tensors.z(. This will likely change in the future. rMr BoundingBoxes KeyPointsMaskrtrutyper2rKr(r,r r#rrrRs r-r(FiveCrop._call_kernelg} dZ55z7K7KZ__] ^ ^ MM:&&'("4j1122Z\ w#JFtFvFFr0r$cVUR[RXR5$r')r(r) five_croprEr+s r-r.FiveCrop.transformos  dII>>r0r{c[U[R[R5(a"[ S[ U5R S35egNz1BoundingBoxes'es and Mask's are not supported by z()rr rrrsrr2r,r{s r- check_inputsFiveCrop.check_inputsrE ; 8 8*// J JOPTUYPZPcPcOddfgh h Kr0rk)r2r3r4r5r6r7rr8rrNrrLrrr(r9r:r.rPrr;rYrZs@r-rr<s"H$,,gU3 #56g4gGxGsG3GRUGZ]G?c?4S>?c?iS idiir0rc ^\rSrSrSr\R rSS\\ \ \ 4S\ SS4U4Sjjjr S\ S \S \S \S\4 U4S jjrS \\SS4SjrS \S\\\4S\4SjrSrU=r$)TenCropiwaCrop the image or video into four corners and the central crop plus the flipped version of these (horizontal flipping is used by default). If the input is a :class:`torch.Tensor` or a :class:`~torchvision.tv_tensors.Image` or a :class:`~torchvision.tv_tensors.Video` it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. See :class:`~torchvision.transforms.v2.FiveCrop` for an example. .. Note:: This transform returns a tuple of images and there may be a mismatch in the number of inputs and targets your Dataset returns. See below for an example of how to deal with this. Args: size (sequence or int): Desired output size of the crop. If size is an int instead of sequence like (h, w), a square crop (size, size) is made. If provided a sequence of length 1, it will be interpreted as (size[0], size[0]). vertical_flip (bool, optional): Use vertical flipping instead of horizontal rEr@r%NcL>[TU]5 [USS9UlX lgr_)rKrLrrEr@)r,rEr@rRs r-rLTenCrop.__init__s# 0ef *r0r r#rrc,>[U[R[R[R45(aB[ R "[U5RS[U5RS35 [TU]("X/UQ70UD6$rrrs r-r(TenCrop._call_kernelrr0r{c[U[R[R5(a"[ S[ U5R S35egrrrs r-rTenCrop.check_inputsrr0r$chUR[RXRURS9$)N)r@)r(r)ten_croprEr@r+s r-r.TenCrop.transforms(  T99DL^L^ __r0)rEr@)F)r2r3r4r5r6r7rr8rrNrrXrLrrr(rPrr9r:r.r;rYrZs@r-rrws*$+++U3 #56+t+X\++ GxGsG3GRUGZ]GiS idi`c`4S>`c``r0rc ^\rSrSrSr\R rS\\ \ 44U4Sjjr SS\ \ \\ 4S\ \\\ \\ 4\44S\SSS 4U4S jjjrS \ S \\ \ 4S\ 4S jrSrU=r$)Padia<Pad the input on all sides with the given "pad" value. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: padding (int or sequence): Padding on each border. If a single int is provided this is used to pad all borders. If sequence of length 2 is provided this is the padding on left/right and top/bottom respectively. If a sequence of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. .. note:: In torchscript mode padding as single int is not supported, use a sequence of length 1: ``[padding, ]``. fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. padding_mode (str, optional): Type of padding. Should be: constant, edge, reflect or symmetric. Default is "constant". - constant: pads with a constant value, this value is specified with fill - edge: pads with the last value at the edge of the image. - reflect: pads with reflection of image without repeating the last value on the edge. For example, padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2] - symmetric: pads with reflection of image repeating the last value on the edge. For example, padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3] r%c>[TU]5nUSbL[US[[45(d.[ [ U5RSURS35eU$)Nfill5() can only be scripted for a scalar `fill`, but got .) rK _extract_params_for_v1_transformrMrNrrQrr2r)r,r$rRs r-r$Pad._extract_params_for_v1_transforms`9;v&*VF^c5\*R*RT 3 344ijnjsjsittuvw w r0paddingr padding_modeconstantedgereflect symmetricNc>[TU]5 [U5 [U5 [ U[ 5(d [ U5nXlX l[U5Ul X0l gr') rKrLrrrMrNrPrrr_fillr)r,rrrrRs r-rL Pad.__init__sT 7# -'3''7mG  $T* (r0r#r$c[UR[U55nUR[R XR X0RS9$)Nrrr)rrrr(r)padrrr,r#r$rs r-r. Pad.transforms<T$Z0  ll\m\m nnr0)rrrr)rr)r2r3r4r5r6r7rr8r9r:rrrrNrrrrrLr.r;rYrZs@r-rrs#J$$sCx.EFLV )sHSM)*)ItE$)$4i$?@@A)HI )  ))&oco4S>ocoor0rc ^\rSrSrSrSS\\\\\\ 4\44S\ \ S\ SS4U4Sjjjr S \ \S\\ \44S jrS \S \\ \4S\4S jrSrU=r$) RandomZoomOutia"Zoom out" transformation from `"SSD: Single Shot MultiBox Detector" `_. This transformation randomly pads images, videos, bounding boxes and masks creating a zoom out effect. Output spatial size is randomly sampled from original size up to a maximum size configured with ``side_range`` parameter: .. code-block:: python r = uniform_sample(side_range[0], side_range[1]) output_width = input_width * r output_height = input_height * r If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. side_range (sequence of floats, optional): tuple of two floats defines minimum and maximum factors to scale the input size. p (float, optional): probability that the zoom operation will be performed. r side_rangepr%Nc>[TU]US9 Xl[U5Ul[ USSS9 X lUSS:d USUS:a[SUS 35eg) NrrrJ req_sizesrrorzInvalid side range provided r)rKrLrrrrrrQ)r,rrrrRs r-rLRandomZoomOut.__init__ sm 1 $T* j,$G$ a=3 *Q-*Q-"?;JEF&0 KItE$)$4i$?@@AKUOK  K  KK"%tCy%T#s(^% CcC4S>CcCCr0rc^\rSrSrSr\R r\RSSS4S\ \ R\ 4S\ \\4S\S \\\S \ \\\ \\4\44S S4 U4S jjjrS \\S \\\44SjrS\S\\\4S \4SjrSrU=r$)RandomRotationi0a Rotate the input by angle. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: degrees (sequence or number): Range of degrees to select from. If degrees is a number instead of sequence like (min, max), the range of degrees will be [-degrees, +degrees]. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.NEAREST``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.BILINEAR`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. expand (bool, optional): Optional expansion flag. If true, expands the output to make it large enough to hold the entire rotated image. If false or omitted, make the output image the same size as the input image. Note that the expand flag assumes rotation around the center (see note below) and no translation. center (sequence, optional): Optional center of rotation, (x, y). Origin is the upper left corner. Default is the center of the image. .. note:: In theory, setting ``center`` has no effect if ``expand=True``, since the image center will become the center of rotation. In practice however, due to numerical precision, this can lead to off-by-one differences of the resulting image size compared to using the image center in the first place. Thus, when setting ``expand=True``, it's best to leave ``center=None`` (default). fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. .. _filters: https://pillow.readthedocs.io/en/latest/handbook/concepts.html#filters FNrdegreesrFexpandcenterrr%c>[TU]5 [USSS9UlX lX0lXPl[U5UlUb [USSS9 X@l g)Nrrnamerrr) rKrLrrrFrrrrrr)r,rrFrrrrRs r-rLRandomRotation.__init__YsS #G)tL *  $T*   !&(d C r0r{c[R"S5RURSURS5R 5n[ US9$)Nrr)angle)rvrrrrr9)r,r{rs r-rRandomRotation.make_paramsns@ A'' QaINNP%  r0r#r$c [UR[U55nUR"[R U40UDUR URURUS.D6$)N)rFrrr) rrrr(r)rotaterFrrrs r-r.RandomRotation.transformrs^T$Z0  HH   ,,;;;;  r0)rrrrrrF)r2r3r4r5r6r7rr8rNEARESTrnumbersNumberrrNrXrrPrrr9rr:rLrrr.r;rYrZs@r-rr0s$L$22 8I7P7P(,DE w~~x/0.34  e%  ItE$)$4i$?@@A  *!tCy!T#s(^!  c  4S>  c   r0rcP^\rSrSrSr\R rSSS\RSS4S\ \ R\ 4S\\ \S\\ \S\\ \\\ \4S \ \\4S \ \\\ \\4\44S \\\S S4U4S jjjrS\\S \\\44SjrS\S\\\4S \4SjrSrU=r$) RandomAffineia Random affine transformation the input keeping center invariant. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: degrees (sequence or number): Range of degrees to select from. If degrees is a number instead of sequence like (min, max), the range of degrees will be (-degrees, +degrees). Set to 0 to deactivate rotations. translate (tuple, optional): tuple of maximum absolute fraction for horizontal and vertical translations. For example translate=(a, b), then horizontal shift is randomly sampled in the range -img_width * a < dx < img_width * a and vertical shift is randomly sampled in the range -img_height * b < dy < img_height * b. Will not translate by default. scale (tuple, optional): scaling factor interval, e.g (a, b), then scale is randomly sampled from the range a <= scale <= b. Will keep original scale by default. shear (sequence or number, optional): Range of degrees to select from. If shear is a number, a shear parallel to the x-axis in the range (-shear, +shear) will be applied. Else if shear is a sequence of 2 values a shear parallel to the x-axis in the range (shear[0], shear[1]) will be applied. Else if shear is a sequence of 4 values, an x-axis shear in (shear[0], shear[1]) and y-axis shear in (shear[2], shear[3]) will be applied. Will not apply shear by default. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.NEAREST``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.BILINEAR`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. center (sequence, optional): Optional center of rotation, (x, y). Origin is the upper left corner. Default is the center of the image. .. _filters: https://pillow.readthedocs.io/en/latest/handbook/concepts.html#filters Nrr translaterpshearrFrrr%c>[T U]5 [USSS9UlUb.[ USSS9 UHnSUs=::aS::aMO [ S5e X lUb%[ US SS9 UHn U S ::dM [ S 5e X0lUb[US S S9UlOX@lXPl X`l [U5Ul Ub [ USSS9 Xpl g)Nrrrrrroz,translation values should be between 0 and 1rprzscale values should be positiver )rJr)rKrLrrrrQrrpr rFrrrr) r,rrrpr rFrrtsrRs r-rLRandomAffine.__init__s #G)tL  !)[D IqC$%STT#   !%D A6$%FGG  %e'VLDJJ* $T*   !&(d C r0r{c[U5up#[R"S5RURSURS5R 5nUR b[UR SU-5n[UR SU-5n[[[R"S5RU*U5R 555n[[[R"S5RU*U5R 555nXx4n OSn URbO[R"S5RURSURS5R 5n OSn S=pURb[R"S5RURSURS5R 5n [UR5S:XaN[R"S5RURSURS5R 5n X4n [XIXS 9$) Nrr)rrror r rJ)rrrpr )rrvrrrrrrrNrrpr rOr9)r,r{rrrmax_dxmax_dytxtyrrpshear_xshear_yr s r-rRandomAffine.make_paramss";/  A'' QaINNP >> %4>>!,u45F4>>!,v56FU5;;q>22F7FCHHJKLBU5;;q>22F7FCHHJKLBII :: !KKN++DJJqM4::a=INNPEE :: !kk!n--djjmTZZ]KPPRG4::!#++a.11$**Q-AOTTV"%EOOr0r#r$c[UR[U55nUR"[R U40UDUR UURS.D6$)N)rFrr)rrrr(r)affinerFrrs r-r.RandomAffine.transformsWT$Z0  HH   ,,;;   r0)rrrrrFrpr r)r2r3r4r5r6r7rr8rrrrrrrrrNrr9rr:rPrLrrr.r;rYrZs@r-rrs9%N$00 04+/>B7H7P7PDE(,%w~~x/0%HUO,%( % c5(5/9:; % .34 %ItE$)$4i$?@@A%e%% %%NPtCyPT#s(^P6  c  4S>  c   r0rc^\rSrSrSr\R rS\\ \ 44U4Sjjr SS\ \ \\ 4S\\ \ \\ 4S\S \ \\\ \\ 4\44S \S SS4 U4S jjjrS \\ S\\ \ 44SjrS\ S\\ \ 4S\ 4SjrSrU=r$) RandomCropiaT Crop the input at a random location. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: size (sequence or int): Desired output size of the crop. If size is an int instead of sequence like (h, w), a square crop (size, size) is made. If provided a sequence of length 1, it will be interpreted as (size[0], size[0]). padding (int or sequence, optional): Optional padding on each border of the image, applied before cropping. Default is None. If a single int is provided this is used to pad all borders. If sequence of length 2 is provided this is the padding on left/right and top/bottom respectively. If a sequence of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. .. note:: In torchscript mode padding as single int is not supported, use a sequence of length 1: ``[padding, ]``. pad_if_needed (boolean, optional): It will pad the image if smaller than the desired size to avoid raising an exception. Since cropping is done after padding, the padding seems to be done at a random offset. fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. padding_mode (str, optional): Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. - constant: pads with a constant value, this value is specified with fill - edge: pads with the last value at the edge of the image. - reflect: pads with reflection of image without repeating the last value on the edge. For example, padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2] - symmetric: pads with reflection of image repeating the last value on the edge. For example, padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3] r%c>[TU]5nUSbL[US[[45(d.[ [ U5RSURS35eURnUb Uup4pVX5XF/nX!S'U$)Nrrrr) rKrrMrNrrQrr2rr)r,r$rpad_left pad_rightpad_top pad_bottomrRs r-r+RandomCrop._extract_params_for_v1_transform&s9;v&*VF^c5\*R*RT 3 344ijnjsjsittuvw w,,  7> 4H)@G#y r0NrEr pad_if_neededrrrc$>[TU]5 [USS9UlU(dUbUb [ U5 [ U5 U(a[ RRU5OSUl X0l X@l [U5Ul XPlgr_)rKrLrrErrr) _geometry_parse_pad_paddingrr$rrrr)r,rErr$rrrRs r-rLRandomCrop.__init__4st 0ef G/""7+ #L 1BIq{{55g>t * $T* (r0r{c [U5up#URbURupEpgX&U-- nX4U-- nOS=n=n=pgURupUR(a2X(:aX- n Xj- nXz- nUSU -- nX9:aX- n XJ- nXZ- nUSU -- nX(:dX9:a&[ SX4SURbSOSSX#4S35eXFXW/n [ U 5n X(:a&S [ [R"SX(- S -S S 954OS upX9:a&S [ [R"SX9- S -S S 954OS unn[U =(d UUUUU U U S9$)NrrJzRequired crop size z is larger than zpadded zinput image size rTrr1rk)Fr) needs_croprrrr needs_padr) rrrEr$rQanyrNrvrr9)r,r{ padded_height padded_widthrr r!r"cropped_height cropped_widthdiffrr,needs_vert_croprneeds_horz_croprs r-rRandomCrop.make_paramsKs&0&=# << #7;|| 4H z1 1M y0 0L:; ;H ;y ;7(, %   -%5" T) +$3 ! D(  )\-I%~&E%FFV $ 89bAARTaSpRqqrt  i<L -3u}}Q (F(JQSTU V +3u}}Q (Dq(HrRS T  &9/!  r0r#r$c US(aK[UR[U55nUR[R XSX0R S9nUS(a-UR[RXSUSUSUSS 9nU$) Nr,rrr+rrrrr)rrrr(r)rrcroprs r-r.RandomCrop.transforms + TZZd4D$$QUUD:KRVevev$wD , $$-fVnVT\M]eklset%D r0)rrr$rrrE)NFrr)r2r3r4r5r6r7rr8r9r:rrrrNrrrXrrrrLrPrr.r;rYrZs@r-rrs*X$.. $sCx. "8<#DELV )C#&')%Xc] 234) ) ItE$)$4i$?@@A ) HI ) )).8 tCy8 T#s(^8 t c 4S> c  r0rc^\rSrSrSr\R rSS\RS4S\ S\ S\ \\ 4S\ \ \\ \\4\ 44S S 4 U4S jjjrS \\S \\\44S jrS\S\\\4S \4SjrSrU=r$)RandomPerspectiveiaPerform a random perspective transformation of the input with a given probability. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: distortion_scale (float, optional): argument to control the degree of distortion and ranges from 0 to 1. Default is 0.5. p (float, optional): probability of the input being transformed. Default is 0.5. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.BILINEAR`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. rrdistortion_scalerrFrr%Nc>[TU]US9 SUs=::aS::d O [S5eXlX0lX@l[ U5Ulg)Nrrrz9Argument distortion_scale value should be between 0 and 1)rKrLrQr;rFrrr)r,r;rrFrrRs r-rLRandomPerspective.__init__sL 1%**XY Y 0* $T* r0r{c [U5up#URnUS-nUS-n[XE-5S-n[XF-5S-n[[R"SUSS95[[R"SUSS95/n [[R"X8- USS95[[R"SUSS95/n [[R"X8- USS95[[R"X'- USS95/n [[R"SUSS95[[R"X'- USS95/n SS/US- S/US- US- /SUS- //n XX/n[ X5n[ US9$)NrJrrr~rk) coefficients)rr;rNrvrr r9)r,r{rrr; half_height half_width bound_height bound_widthtoplefttoprightbotrightbotleft startpoints endpointsperspective_coeffss r-rRandomPerspective.make_paramss{";/ 00k aZ +9:Q> *781<  a48 9  aD9 :   e15tD E  aD9 :   e15tD E  f3V$G H   a48 9  f3V$G H 1v 1~ 6A:/FFUVJX : 4[L!344r0r#r$c[UR[U55nUR"[R U4SSUUR S.UD6$)N)rHrIrrF)rrrr(r) perspectiverFrs r-r.RandomPerspective.transformsVT$Z0  MM  ,,    r0)rr;rrF)r2r3r4r5r6r7r:r8rrWrrrNrr9rr:rLrPrrr.r;rYrZs@r-r:r:s,$55#&7H7Q7QDE ++ +.34 + ItE$)$4i$?@@A +  ++"5tCy5T#s(^5<  c  4S>  c   r0r:c^\rSrSrSr\R rSS\RS4S\ \ \ \ 4S\ \ \ \ 4S\ \\ 4S \ \\\ \\4\44S S 4 U4S jjjrS \\S \\\44SjrS\S\\\4S \4SjrSrU=r$)ElasticTransformiak Transform the input with elastic transformations. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Given alpha and sigma, it will generate displacement vectors for all pixels based on random offsets. Alpha controls the strength and sigma controls the smoothness of the displacements. The displacements are added to an identity grid and the resulting grid is used to transform the input. .. note:: Implementation to transform bounding boxes is approximative (not exact). We construct an approximation of the inverse grid as ``inverse_grid = identity - displacement``. This is not an exact inverse of the grid used to transform images, i.e. ``grid = identity + displacement``. Our assumption is that ``displacement * displacement`` is small and can be ignored. Large displacements would lead to large errors in the approximation. Applications: Randomly transforms the morphology of objects in images and produces a see-through-water-like effect. Args: alpha (float or sequence of floats, optional): Magnitude of displacements. Default is 50.0. A single value is ``[alpha, alpha]``. sigma (float or sequence of floats, optional): Smoothness of displacements. Default is 5.0. A single value is ``[sigma, sigma]``. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.BILINEAR`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. fill (number or tuple or dict, optional): Pixel fill value used when the ``padding_mode`` is constant. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Fill value can be also a dictionary mapping data type to the fill value, e.g. ``fill={tv_tensors.Image: 127, tv_tensors.Mask: 0}`` where ``Image`` will be filled with 127 and ``Mask`` will be filled with 0. gI@g@ralphasigmarFrr%Nc>[TU]5 [US5Ul[US5UlX0lX@l[U5Ulg)NrQrR) rKrLrrQrRrFrrr)r,rQrRrFrrRs r-rLElasticTransform.__init__sC )%9 )%9 * $T* r0r{c[U5up#[R"SSX#5S-S- nURSS:ab[ SURS-S-5nUS-S:XaUS- nUR [ RXEU/[UR55nX@RS-U- n[R"SSX#5S-S- nURSS:ab[ SURS-S-5nUS-S:XaUS- nUR [ RXgU/[UR55nX`RS-U- n[R"XF/S5R/SQ5n[US9$)NrrJrr )rrJrr) displacement) rrvrrRrNr(r) gaussian_blurrPrQconcatpermuter9) r,r{rrdxkxdykyrWs r-rElasticTransform.make_params!sb";/  ZZ1f ,q 01 4 ::a=3 QA&*+BAv{a""1??BR$tzzBRSB **Q- % ' ZZ1f ,q 01 4 ::a=3 QA&*+BAv{a""1??BR$tzzBRSB **Q- & (||RHa088F ..r0r#r$c[UR[U55nUR"[R U40UDUUR S.D6$)N)rrF)rrrr(r)elasticrFrs r-r.ElasticTransform.transform8sPT$Z0  II   ,,   r0)rrQrrFrR)r2r3r4r5r6r7rPr8rrWrrrrNrr9rr:rLrPrrr.r;rYrZs@r-rPrPs&P$4404/27H7Q7QDE +UHUO+, +UHUO+, +.34 + ItE$)$4i$?@@A +  + +/tCy/T#s(^/. c 4S> c  r0rPc ^\rSrSrSrSS\S\S\S\S\\\S \4 U4S jjjr S \\ S S4S jr S \\ S \ \ \ 44SjrS\ S\ \ \ 4S \ 4SjrSrU=r$) RandomIoUCropiCaRandom IoU crop transformation from `"SSD: Single Shot MultiBox Detector" `_. This transformation requires an image or video data and ``tv_tensors.BoundingBoxes`` in the input. .. warning:: In order to properly remove the bounding boxes below the IoU threshold, `RandomIoUCrop` must be followed by :class:`~torchvision.transforms.v2.SanitizeBoundingBoxes`, either immediately after or later in the transforms pipeline. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: min_scale (float, optional): Minimum factors to scale the input size. max_scale (float, optional): Maximum factors to scale the input size. min_aspect_ratio (float, optional): Minimum aspect ratio for the cropped image or video. max_aspect_ratio (float, optional): Maximum aspect ratio for the cropped image or video. sampler_options (list of float, optional): List of minimal IoU (Jaccard) overlap between all the boxes and a cropped image or video. Default, ``None`` which corresponds to ``[0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0]`` trials (int, optional): Number of trials to find a crop for a given value of minimal IoU (Jaccard) overlap. Default, 40. N min_scale max_scalemin_aspect_ratiomax_aspect_ratiosampler_optionstrialscx>[TU]5 XlX lX0lX@lUc/SQnXPlX`lg)N)r 皙?333333?rgffffff?g?ro)rKrLrerfrgrhoptionsrj)r,rerfrgrhrirjrRs r-rLRandomIoUCrop.__init__^s; "" 0 0  "AO&  r0r{r%c[U[R5(a=[U[R R [R [ 5(d![[U5RS35eg)Nzk() requires input sample to contain tensor or PIL images and bounding boxes. Sample can also contain masks.) rr rrPILImagerrsrr2rs r-rRandomIoUCrop.check_inputsrsc K!9!9 : : SYY__j6F6FWW:&&'(EE Xr0c [U5up#[U5n[[R"S[ UR 5SS95nUR UnUS:a [5$[UR5GHnURURUR- [R"S5--n[X8S-5n [X(S-5n X- n URU s=::aUR::dO M[R"S5n[X9- US-5n [X*- US-5n X-nX-nX:XdX:XaM[R "UR#[R$5UR&[(R*R,5nSUSUS --nSUS US --nU U:UU:-U U:-UU:-nUR/5(dGM|UUn[1U[R2"XX//UR4UR6S 95nUR95U:aGM[XXUS 9s $ GMG)Nrr~)lowhighrErorJrr).r).rJ).r).r)dtypedevice)rrrris_within_crop_area)rrrNrvrrOrnr9rrjrerfrrgrhr)convert_bounding_box_format as_subclassTensorformatr BoundingBoxFormatXYXYr-r rxrwrxr)r,r{rrbboxesidxmin_jaccard_overlaprrnew_wnew_hrrrrr xyxy_bboxescxcyryiouss r-rRandomIoUCrop.make_params|s<#K0#K0emmDLL0AMNC"&,,s"3 "c)v 4;;'NNdnnt~~&ETU%VVFqTM*FqTM*$} --VAVAVVJJqMFNad236>QqT12 =CM ;;&&u||4MM0055 K/+f2EEFK/+f2EEF'+byR%Z&@C"H&MQSV\Q\&]#*..00**=> LL4e"cr0rdc ^\rSrSrSrS\R S4S\\\4S\\ \ 4S\ \\4S\ \ 4U4S jjjr S \\S \\\44S jrS \S\\\4S \4SjrSrU=r$) ScaleJitteria` Perform Large Scale Jitter on the input according to `"Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation" `_. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: target_size (tuple of int): Target size. This parameter defines base scale for jittering, e.g. ``min(target_size[0] / width, target_size[1] / height)``. scale_range (tuple of float, optional): Minimum and maximum of the scale range. Default, ``(0.1, 2.0)``. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.NEAREST_EXACT``, ``InterpolationMode.BILINEAR`` and ``InterpolationMode.BICUBIC`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. antialias (bool, optional): Whether to apply antialiasing. It only affects **tensors** with bilinear or bicubic modes and it is ignored otherwise: on PIL images, antialiasing is always applied on bilinear or bicubic modes; on other modes (for PIL images and tensors), antialiasing makes no sense and this parameter is ignored. Possible values are: - ``True`` (default): will apply antialiasing for bilinear or bicubic modes. Other mode aren't affected. This is probably what you want to use. - ``False``: will not apply antialiasing for tensors on any mode. PIL images are still antialiased on bilinear or bicubic modes, because PIL doesn't support no antialias. - ``None``: equivalent to ``False`` for tensors and ``True`` for PIL images. This value exists for legacy reasons and you probably don't want to use it unless you really know what you are doing. The default value changed from ``None`` to ``True`` in v0.17, for the PIL and Tensor backends to be consistent. )rlrT target_size scale_rangerFrHcR>[TU]5 XlX lX0lX@lgr')rKrLrrrFrH)r,rrrFrHrRs r-rLScaleJitter.__init__s' &&*"r0r{r%cN[U5up#URS[R"S5URSURS- --n[ UR SU- UR SU- 5U-n[ X5-5n[ X%-5n[Xv4S9$)Nrrrk)rrrvrrrrNr9)r,r{ orig_height orig_widthrpr new_width new_heights r-rScaleJitter.make_paramss",["9   #ejjmt7G7G7JTM]M]^_M`7`&aa   #k143C3CA3F3S TW\ \ ' ) *011r0r#r$cpUR[RXSURURS9$NrErr(r)rUrFrHr+s r-r.ScaleJitter.transform8  HHdt?Q?Q]a]k]k!  r0)rHrFrr)r2r3r4r5r6rrWrrNrrrrXrLrPrr9r:rr.r;rYrZs@r-rrs#P,67H7Q7Q$( #38_ #5%<( #.34 # D> # #2tCy2T#s(^2 c 4S> c  r0rc ^\rSrSrSrS\R S4S\\\ \ \ \ 4S\ \ S\\\ 4S\ \ 4U4S jjjr S \\S \\\44S jrS \S\\\4S \4SjrSrU=r$)RandomShortestSizeiapRandomly resize the input. If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: min_size (int or sequence of int): Minimum spatial size. Single integer value or a sequence of integer values. max_size (int, optional): Maximum spatial size. Default, None. interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.NEAREST_EXACT``, ``InterpolationMode.BILINEAR`` and ``InterpolationMode.BICUBIC`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. antialias (bool, optional): Whether to apply antialiasing. It only affects **tensors** with bilinear or bicubic modes and it is ignored otherwise: on PIL images, antialiasing is always applied on bilinear or bicubic modes; on other modes (for PIL images and tensors), antialiasing makes no sense and this parameter is ignored. Possible values are: - ``True`` (default): will apply antialiasing for bilinear or bicubic modes. Other mode aren't affected. This is probably what you want to use. - ``False``: will not apply antialiasing for tensors on any mode. PIL images are still antialiased on bilinear or bicubic modes, because PIL doesn't support no antialias. - ``None``: equivalent to ``False`` for tensors and ``True`` for PIL images. This value exists for legacy reasons and you probably don't want to use it unless you really know what you are doing. The default value changed from ``None`` to ``True`` in v0.17, for the PIL and Tensor backends to be consistent. NTmin_sizerGrFrHc>[TU]5 [U[5(aU/O [ U5UlX lX0lX@lgr') rKrLrMrNrPrrGrFrHr,rrGrFrHrRs r-rLRandomShortestSize.__init__(s; &03&?&? T(^  *"r0r{r%c\[U5up#UR[[R"[ UR5S55nU[ X#5- nURb![ XPR[X#5- 5n[X5-5n[X%-5n[Xv4S9$Nr1rk) rrrNrvrrOrrGrr9)r,r{rrrrrrs r-rRandomShortestSize.make_params5s",["9 ==U]]3t}}3Er%J!KL s;3 3 == $A}}s;'CCDA ' ) *011r0r#r$cpUR[RXSURURS9$rrr+s r-r.RandomShortestSize.transformBrr0rHrFrGr)r2r3r4r5r6rrWrrPrNrrrXrLrr9r:rr.r;rYrZs@r-rrs!L#'7H7Q7Q$( #S 5:s23 #3- #.34 # D> # # 2tCy 2T#s(^ 2 c 4S> c  r0rc ^\rSrSrSr\R S4S\S\S\\\4S\ \ SS 4 U4S jjjr S \ \ S\\\ 44S jrS \ S\\\ 4S\ 4SjrSrU=r$) RandomResizeiHa Randomly resize the input. This transformation can be used together with ``RandomCrop`` as data augmentations to train models on image segmentation task. Output spatial size is randomly sampled from the interval ``[min_size, max_size]``: .. code-block:: python size = uniform_sample(min_size, max_size) output_width = size output_height = size If the input is a :class:`torch.Tensor` or a ``TVTensor`` (e.g. :class:`~torchvision.tv_tensors.Image`, :class:`~torchvision.tv_tensors.Video`, :class:`~torchvision.tv_tensors.BoundingBoxes` etc.) it can have arbitrary number of leading batch dimensions. For example, the image can have ``[..., C, H, W]`` shape. A bounding box can have ``[..., 4]`` shape. Args: min_size (int): Minimum output size for random sampling max_size (int): Maximum output size for random sampling interpolation (InterpolationMode, optional): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.BILINEAR``. If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.NEAREST_EXACT``, ``InterpolationMode.BILINEAR`` and ``InterpolationMode.BICUBIC`` are supported. The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. antialias (bool, optional): Whether to apply antialiasing. It only affects **tensors** with bilinear or bicubic modes and it is ignored otherwise: on PIL images, antialiasing is always applied on bilinear or bicubic modes; on other modes (for PIL images and tensors), antialiasing makes no sense and this parameter is ignored. Possible values are: - ``True`` (default): will apply antialiasing for bilinear or bicubic modes. Other mode aren't affected. This is probably what you want to use. - ``False``: will not apply antialiasing for tensors on any mode. PIL images are still antialiased on bilinear or bicubic modes, because PIL doesn't support no antialias. - ``None``: equivalent to ``False`` for tensors and ``True`` for PIL images. This value exists for legacy reasons and you probably don't want to use it unless you really know what you are doing. The default value changed from ``None`` to ``True`` in v0.17, for the PIL and Tensor backends to be consistent. TrrGrFrHr%NcR>[TU]5 XlX lX0lX@lgr')rKrLrrGrFrHrs r-rLRandomResize.__init__ws%   *"r0r{c[[R"URURS55n[ U/S9$r)rNrvrrrGr9)r,r{rEs r-rRandomResize.make_paramss.5== rBC$  r0r#r$cpUR[RXSURURS9$)NrE)rFrHrr+s r-r.RandomResize.transforms8  HHd6N$:L:LX\XfXf!  r0r)r2r3r4r5r6rrWrNrrrXrLrPrr9r:rr.r;rYrZs@r-rrHs,d8I7Q7Q$( # # #.34 # D> #  # #!tCy!T#s(^! c 4S> c  r0r)?rrrtcollections.abcrtypingrrrrr PIL.Imagerqrv torchvisionr r7r torchvision.ops.boxesr !torchvision.transforms.functionalr torchvision.transforms.v2r r)rr+torchvision.transforms.v2.functional._utilsr _transformr_utilsrrrrrrrrrrrrrr!r=rCr\rmrrrrrrrr:rPrdrrrr1r0r-rsT $:: =)ESSA-":0:$8.8$b Yb JMM4t t n8iy8iv*`i*`ZEo)EoPAC)ACHL YL ^u 9u pXXvR -R jY yY x{I{|@ )@ FA A HC 9C r0