U h@s ddlZddlZddlZddlmZmZmZmZmZm Z m Z m Z m Z m Z ddlZddlZddlmZmZddlmZddlmZddlmZmZmZddlmZdd l m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/Gd d d e!Z0Gd dde!Z1GdddeZ2GdddeZ3GdddeZ4GdddeZ5GdddeZ6GdddeZ7Gddde!Z8GdddeZ9Gdd d eZ:Gd!d"d"eZ;Gd#d$d$e!ZGd)d*d*eZ?Gd+d,d,eZ@Gd-d.d.eZAdS)/N) AnyCallableDictListLiteralOptionalSequenceTupleTypeUnion) 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_sizec@s0eZdZdZejZeee efedddZ dS)RandomHorizontalFlipaHorizontally 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 inptparamsreturncCs|tj|SN) _call_kernelFZhorizontal_flipselfr%r&r-U/var/www/html/venv/lib/python3.8/site-packages/torchvision/transforms/v2/_geometry.py _transform/szRandomHorizontalFlip._transformN) __name__ __module__ __qualname____doc__ _transformsr#_v1_transform_clsrrstrr/r-r-r-r.r#!s r#c@s0eZdZdZejZeee efedddZ dS)RandomVerticalFlipaVertically 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$cCs|tj|Sr()r)r* vertical_flipr+r-r-r.r/AszRandomVerticalFlip._transformN) r0r1r2r3r4r7r5rrr6r/r-r-r-r.r73s r7csveZdZdZejZejddfe e e e dfe ee fe e e e ddfdd Zeeeefeddd ZZS) Resizea 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. NT)size interpolationmax_size antialiasr'cstt|tr|g}nTt|trrz7max_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 ValueErrorr:r;r<r=)r,r:r;r<r= __class__r-r.r@s     zResize.__init__r$cCs |jtj||j|j|j|jdS)N)r;r<r=)r)r*resizer:r;r<r=r+r-r-r.r/szResize._transform)r0r1r2r3r4r9r5rBILINEARr rBrrboolr@rrr6r/ __classcell__r-r-rFr.r9Es= r9csReZdZdZejZeee efdfdd Z e e e e fe dddZZS) 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]). r:cstt|dd|_dSN3Please provide only two dimensions (h, w) for size. error_msgr?r@rr:r,r:rFr-r.r@s zCenterCrop.__init__r$cCs|jtj||jdS)N)Z output_size)r)r*Z center_cropr:r+r-r-r.r/szCenterCrop._transform)r0r1r2r3r4rLr5r rBrr@rrr6r/rKr-r-rFr.rLsrLcseZdZdZejZddejdfe e e e fe e e fe e e fe ee feeddfdd Zeeeeefd d d Zeeeefed d dZZS)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?TN)r:scaleratior;r=r'cstt|dd|_t|ts*tdt|tstopleftheightwidth)r"r^ranger[emptyuniform_rVitemexprBroundmathsqrtrandintfloatminrWmaxdict)r,r`rfrgZareaZ log_ratio_Z target_area aspect_ratiowhijZin_ratior-r-r. _get_paramss:  & 0  zRandomResizedCrop._get_paramsr$cCs$|jtj|f||j|j|jdS)Nr:r;r=)r)r*Z resized_cropr:r;r=r+r-r-r.r/5szRandomResizedCrop._transform)r0r1r2r3r4rTr5rrIr rBrr rqrrJr@rrrr6r{r/rKr-r-rFr.rTs /   &rTcseZdZdZejZeee efddfdd Z e e e e e dfdd Z e eee fe d d d Zee dd d dZZS)FiveCropaCrop 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]) N)r:r'cstt|dd|_dSrNrRrSrFr-r.r@bs zFiveCrop.__init__rr%argskwargsr'csJt|tjtjfr4tt|jdt|jdtj ||f||SNz:() is currently passing through inputs of type tv_tensors.z(. This will likely change in the future. rAr BoundingBoxesMaskrYrZtyper0r?r)r,rr%rrrFr-r.r)fs zFiveCrop._call_kernelr$cCs|tj||jSr()r)r*Z five_cropr:r+r-r-r.r/nszFiveCrop._transformr_cCs*t|tjtjr&tdt|jddSNz1BoundingBoxes'es and Mask's are not supported by z()r r rrrXrr0r,r`r-r-r. _check_inputsqszFiveCrop._check_inputs)r0r1r2r3r4r}r5r rBrr@rrr)rr6r/rrrKr-r-rFr.r};s $ r}cseZdZdZejZdeee efe ddfdd Z e e e e e dfdd Zee dd d d Ze eee fe d ddZZS)TenCropaCrop 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 FN)r:r8r'cs"tt|dd|_||_dSrN)r?r@rr:r8)r,r:r8rFr-r.r@s zTenCrop.__init__r~csJt|tjtjfr4tt|jdt|jdtj ||f||SrrrrFr-r.r)s zTenCrop._call_kernelr_cCs*t|tjtjr&tdt|jddSrrrr-r-r.rszTenCrop._check_inputsr$cCs|jtj||j|jdS)N)r8)r)r*Zten_cropr:r8r+r-r-r.r/szTenCrop._transform)F)r0r1r2r3r4rr5r rBrrJr@rrr)rrrr6r/rKr-r-rFr.rvs $rcseZdZdZejZeee fdfdd Z de e e e fe eee eefeffeddd fd d Ze eee fe d d dZZS)PadaPad 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'csHt}|ddksDt|dttfsDtt|jd|jd|S)Nfill5() can only be scripted for a scalar `fill`, but got .) r? _extract_params_for_v1_transformrArBrqrErr0r)r,r&rFr-r.rs z$Pad._extract_params_for_v1_transformrconstantredgeZreflectZ symmetricN)paddingr padding_moder'csLtt|t|t|ts,t|}||_||_t ||_ ||_ dSr() r?r@rrrArBrDrrr_fillr)r,rrrrFr-r.r@s   z Pad.__init__r$cCs*t|jt|}|jtj||j||jdS)Nrrr)rrrr)r*padrrr,r%r&rr-r-r.r/szPad._transform)rr)r0r1r2r3r4rr5rr6rrr rBrrr rr@r/rKr-r-rFr.rs% rcseZdZdZdeeeeeefeffe e e ddfdd Z e e eee fd d d Ze eee fe d d dZZS) RandomZoomOuta4 "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. rrUg@?N)r side_rangepr'csbtj|d||_t||_t|ddd||_|ddksN|d|dkr^td|d dS) Nrrr> req_sizesrrUrzInvalid side range provided r)r?r@rrrrrrE)r,rrrrFr-r.r@ s zRandomZoomOut.__init__r_c Cst|\}}|jdtd|jd|jd}t||}t||}td}t|||d}t|||d}|||} |||} ||| | g} t| dS)Nrrr>)r)r"rr[randrBrt) r,r`orig_horig_wrZ canvas_widthZ canvas_heightrerdrightbottomrr-r-r.r{s (      zRandomZoomOut._get_paramsr$cCs*t|jt|}|jtj|f|d|iS)Nr)rrrr)r*rrr-r-r.r/*szRandomZoomOut._transform)rrr)r0r1r2r3r rrr r6rrqr@rrr{r/rKr-r-rFr.rsrc seZdZdZejZejdddfe e j e fe ee feeeee eee eefeffddfdd Zeeeeefdd d Zeeeefed d d ZZS)RandomRotationa 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 FNr)degreesr;expandcenterrr'csVtt|ddd|_||_||_||_t||_|dk rLt |ddd||_ dS)Nrrnamerrr) r?r@rrr;rrrrrr)r,rr;rrrrFr-r.r@Xs  zRandomRotation.__init__r_cCs,td|jd|jd}t|dS)Nrr)angle)r[rirjrrkrt)r,r`rr-r-r.r{ms"zRandomRotation._get_paramsr$cCs6t|jt|}|jtj|f||j|j|j|dS)N)r;rrr) rrrr)r*rotater;rrrr-r-r.r/qszRandomRotation._transform)r0r1r2r3r4rr5rNEARESTr numbersNumberrrBrJrrrqrrr r6r@rr{r/rKr-r-rFr.r/s &   rc seZdZdZejZdddejddfe e j e fe e ee e ee e eee efe eefe eee eefeffe eeddfdd Zeeeeefddd Zeeeefed d d ZZS) RandomAffineaf 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 Nr)r translaterVshearr;rrr'c stt|ddd|_|dk rXt|ddd|D]"}d|krLdks4ntdq4||_|dk rt|d dd|D]} | d krxtd qx||_|dk rt|d d d|_n||_||_ ||_ t ||_ |dk rt|ddd||_ dS)NrrrrrrUz,translation values should be between 0 and 1rVrzscale values should be positiver)r>r)r?r@rrrrErrVrr;rrrr) r,rrrVrr;rrtsrFr-r.r@s.    zRandomAffine.__init__r_cCs\t|\}}td|jd|jd}|jdk rt|jd|}t|jd|}tt td| |}tt td| |}||f} nd} |j dk rtd|j d|j d} nd} d} } |j dk rDtd|j d|j d} t |j dkrDtd|j d|j d} | | f} t || | | d S) Nrr)rrrUrrr>)rrrVr)r"r[rirjrrkrrqrBrmrVrrCrt)r,r`rfrgrZmax_dxZmax_dyZtxtyrrVZshear_xZshear_yrr-r-r.r{s& "     $ ""zRandomAffine._get_paramsr$cCs2t|jt|}|jtj|f||j||jdS)N)r;rr)rrrr)r*Zaffiner;rrr-r-r.r/szRandomAffine._transform)r0r1r2r3r4rr5rrr rrrrrqrBrrr r6rr@rr{r/rKr-r-rFr.r~s('     'rc seZdZdZejZeee fdfdd Z de e e e fee e e e fee eee eefeffed dd fd d Zee eee fd ddZe eee fe dddZZS) RandomCropa 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. 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] rcsvt}|ddksDt|dttfsDtt|jd|jd|j }|dk rj|\}}}}||||g}||d<|S)Nrrrr) r?rrArBrqrErr0rr)r,r&rpad_left pad_rightpad_top pad_bottomrFr-r.r%s   z+RandomCrop._extract_params_for_v1_transformNFrrr)r:r pad_if_neededrrr'csrtt|dd|_|s$|dk r<|dk r4t|t||rLtj|nd|_ ||_ ||_ t ||_ ||_dSrN)r?r@rr:rrr*Z _geometryZ_parse_pad_paddingrrrrrr)r,r:rrrrrFr-r.r@3s   zRandomCrop.__init__r_c Cst|\}}|jdk r>|j\}}}}|||7}|||7}nd}}}}|j\}} |jr||kr||} || 7}|| 7}|d| 7}|| kr| |} || 7}|| 7}|d| 7}||ks|| krtd|| fd|jdk rdndd||fd||||g} t| } ||kr6d ttjd||d d d fnd \} }|| krhd ttjd|| d d d fnd \}}t | pz||||| | | dS)Nrr>zRequired crop size z is larger than zpadded zinput image size rTrr-rM)Fr) needs_croprdrerfrg needs_padr) r"rr:rrEanyrBr[rprt)r,r`Z padded_heightZ padded_widthrrrrZcropped_heightZ cropped_widthdiffrrZneeds_vert_croprdZneeds_horz_croprer-r-r.r{JsR      , $$zRandomCrop._get_paramsr$cCsh|dr4t|jt|}|jtj||d||jd}|drd|jtj||d|d|d|dd }|S) Nrrrrrdrerfrgrc)rrrr)r*rrcroprr-r-r.r/szRandomCrop._transform)NFrr)r0r1r2r3r4rr5rr6rrr rBrrrJrr rr@rr{r/rKr-r-rFr.rs",:rc seZdZdZejZddejdfe e e ee fe e e e eefe ffddfdd Zeee eefdd d Zee eefed d d ZZS)RandomPerspectivea&Perform 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. rrN)distortion_scalerr;rr'csLtj|dd|kr"dks,ntd||_||_||_t||_dS)Nrrrz9Argument distortion_scale value should be between 0 and 1)r?r@rErr;rrr)r,rrr;rrFr-r.r@szRandomPerspective.__init__r_cCs>t|\}}|j}|d}|d}t||d}t||d}ttjd|ddttjd|ddg} ttj|||ddttjd|ddg} ttj|||ddttj|||ddg} ttjd|ddttj|||ddg} ddg|ddg|d|dgd|dgg} | | | | g}t| |}t|dS)Nr>rrrbrM)Z coefficients)r"rrBr[rprrt)r,r`rfrgrZ half_heightZ half_widthZ bound_heightZ bound_widthZtopleftZtoprightZbotrightZbotleft startpoints endpointsZperspective_coeffsr-r-r.r{s, ,  zRandomPerspective._get_paramsr$cCs2t|jt|}|jtj|fdd||jd|S)N)rrrr;)rrrr)r*Z perspectiver;rr-r-r.r/szRandomPerspective._transform)r0r1r2r3r4rr5rrIrqr rBrrr r6r@rrr{r/rKr-r-rFr.rs rc seZdZdZejZddejdfe e e e fe e e e fe ee fe e ee eefe ffddfdd Zeeeeefd d d Zeeeefed d dZZS)ElasticTransforma 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. sigma (float or sequence of floats, optional): Smoothness of displacements. Default is 5.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.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@rN)alphasigmar;rr'cs<tt|d|_t|d|_||_||_t||_dS)Nrr) r?r@rrrr;rrr)r,rrr;rrFr-r.r@s    zElasticTransform.__init__r_cCs<tt|}tddg|dd}|jddkrztd|jdd}|ddkr^|d7}|tj|||gt|j}||j d|d}tddg|dd}|jddkrtd|jdd}|ddkr|d7}|tj|||gt|j}||j d|d}t ||gd ddddg}t |dS)Nrr>rrr) displacement) rDr"r[rrrBr)r*Z gaussian_blurrconcatZpermutert)r,r`r:ZdxZkxZdykyrr-r-r.r{s"   zElasticTransform._get_paramsr$cCs.t|jt|}|jtj|f|||jdS)N)rr;)rrrr)r*Zelasticr;rr-r-r.r/5szElasticTransform._transform)r0r1r2r3r4rr5rrIr rqrrBrrr r6r@rrr{r/rKr-r-rFr.rs& rcseZdZdZdeeeeeeeedfd d Zee dd d d Z ee e e e fd ddZ e e e e fe dddZZS) RandomIoUCropaCRandom 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. 333333?rUr@N() min_scale max_scalemin_aspect_ratiomax_aspect_ratiosampler_optionstrialscsLt||_||_||_||_|dkrrr).r).r>).r).r)dtypedevice)rdrerfrgis_within_crop_area)r"rrBr[rprCrrtrhrrrrrrr*Zconvert_bounding_box_formatZ as_subclassZTensorformatr ZBoundingBoxFormatZXYXYrrr]rrrs)r,r`rrZbboxesidxZmin_jaccard_overlaprurZnew_wZnew_hrvrerdrrZ xyxy_bboxesZcxcyrZiousr-r-r.r{ysL      zRandomIoUCrop._get_paramsr$cCsVt|dkr|S|jtj||d|d|d|dd}t|tjrRd||d<|S) Nrrdrerfrgrcrr)rCr)r*rrAr r)r,r%r&outputr-r-r.r/s  zRandomIoUCrop._transform)rrUrrNr)r0r1r2r3rqrrrBr@rrrr6r{r/rKr-r-rFr.r@s$  4rcseZdZdZdejdfeeefeeefe eefe e dfdd Z e eeeefddd Zeeeefed d d ZZS) ScaleJittera 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. )rrT) target_size scale_ranger;r=cs&t||_||_||_||_dSr()r?r@rrr;r=)r,rrr;r=rFr-r.r@s  zScaleJitter.__init__r_cCs|t|\}}|jdtd|jd|jd}t|jd||jd||}t||}t||}t||fdS)NrrrM)r"rr[rrrrrBrt)r,r` orig_height orig_widthrVr new_width new_heightr-r-r.r{s  ("  zScaleJitter._get_paramsr$cCs|jtj||d|j|jdSNr:r|r)r*rHr;r=r+r-r-r.r/szScaleJitter._transform)r0r1r2r3rrIr rBrqr rrJr@rrrr6r{r/rKr-r-rFr.rs(     rcseZdZdZdejdfeeee eefe eeeefe e dfdd Z ee eee fddd Ze eee fe d d d ZZS) RandomShortestSizeaRandomly 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. NT)min_sizer<r;r=cs:tt|tr|gnt||_||_||_||_dSr() r?r@rArBrDrr<r;r=r,rr<r;r=rFr-r.r@%s  zRandomShortestSize.__init__r_cCs|t|\}}|jttt|jd}|t||}|jdk rVt||jt||}t||}t||}t ||fdSNr-rM) r"rrBr[rprCrrr<rsrt)r,r`rrrrrrr-r-r.r{2s    zRandomShortestSize._get_paramsr$cCs|jtj||d|j|jdSrrr+r-r-r.r/?szRandomShortestSize._transform)r0r1r2r3rrIr rrBr rrJr@rrr6r{r/rKr-r-rFr.rs&   rcsxeZdZdZejdfeeeeefee ddfdd Z e e e ee fddd Ze e ee fe d d d ZZS) RandomResizea 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. TN)rr<r;r=r'cs&t||_||_||_||_dSr()r?r@rr<r;r=rrFr-r.r@ts  zRandomResize.__init__r_cCs"tt|j|jd}t|gdSr)rBr[rprr<rt)r,r`r:r-r-r.r{szRandomResize._get_paramsr$cCs|jtj||d|j|jdS)Nr:)r;r=rr+r-r-r.r/szRandomResize._transform)r0r1r2r3rrIrBr rrJr@rrrr6r{r/rKr-r-rFr.rEs2  r)BrnrrYtypingrrrrrrrr r r Z PIL.Imagerr[Z torchvisionr r4r Ztorchvision.ops.boxesrZ!torchvision.transforms.functionalrZtorchvision.transforms.v2rr*rrZ+torchvision.transforms.v2.functional._utilsrr/rZ_utilsrrrrrrrrrrr r!r"r#r7r9rLrTr}rrrrrrrrrrrrr-r-r-r.s>0    <ew;-HDOxUZ~CD