a  d{ @sdddlZddlmZmZmZmZmZddlZddl m Z m Z m Z m Z mZmZddlmZmZmZmZmZddlmZmZmZmZmZerddlZddl mZerddlZerddlZ erddl!mZ"dGej#ee e$feee e$fej#dd d Z%dej&fej#e'ee ej#d d d Z(ddZ)dHeej#ddddfee*ddddZ+dIej#ee,ee,e,fee,ee,fe*ee,e-dddZ.dJee,e,fdee,ee e*ej#dddZ/dKej#ee'ee'fee'ee'fee ej#dd d!Z0dLej#ee,e,feee$e fee*ej#d"d#d$Z1ddd%d&d'Z2ej#ej#d%d(d)Z3ddd%d*d+Z4eed%d,d-Z5ddd.d/d0Z6ej#ej#d.d1d2Z7ddd.d3d4Z8eed.d5d6Z9d7d8Z:d9d:Z;Gd;d<dd?d@Z>e e dAdBdCZ?dMej#ee ej#dDdEdFZ@dS)NN)IterableListOptionalTupleUnion)ChannelDimension ImageInputget_channel_dimension_axisget_image_sizeinfer_channel_dimension_formatto_numpy_array) ExplicitEnum TensorType is_jax_tensor is_tf_tensoris_torch_tensor)is_flax_availableis_tf_availableis_torch_availableis_vision_availablerequires_backends)PILImageResampling)image channel_diminput_channel_dimreturncCst|tjstdt||dur.t|}t|}||krB|S|tjkrX|d}n$|tj krn|d}ntd ||S)au Converts `image` to the channel dimension format specified by `channel_dim`. Args: image (`numpy.ndarray`): The image to have its channel dimension set. channel_dim (`ChannelDimension`): The channel dimension format to use. Returns: `np.ndarray`: The image with the channel dimension set to `channel_dim`. ,Input image must be of type np.ndarray, got N)rr)rrrz(Unsupported channel dimension format: {}) isinstancenpndarray ValueErrortyper rFIRSTZ transposeLASTformat)rrrZtarget_channel_dimr'f/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/transformers/image_transforms.pyto_channel_dimension_format6s     r))rscale data_formatrcCsFt|tjstdt|||}|dur8t||}||}|S)ak Rescales `image` by `scale`. Args: image (`np.ndarray`): The image to rescale. scale (`float`): The scale to use for rescaling the image. data_format (`ChannelDimension`, *optional*): The channel dimension format of the image. If not provided, it will be the same as the input image. dtype (`np.dtype`, *optional*, defaults to `np.float32`): The dtype of the output image. Defaults to `np.float32`. Used for backwards compatibility with feature extractors. Returns: `np.ndarray`: The rescaled image. rN)rr r!r"r#r)astype)rr*r+dtypeZrescaled_imager'r'r(rescale[s   r.cCs|jtjkrd}nt||trftd|krFt|dkrFd}qtd|d| dn@td|krt|dkrd}ntd |d| d|S) z Detects whether or not the image needs to be rescaled before being converted to a PIL image. The assumption is that if the image is of type `np.float` and all values are between 0 and 1, it needs to be rescaled. FrzZThe image to be converted to a PIL image contains values outside the range [0, 255], got [z, z%] which cannot be converted to uint8.rTzXThe image to be converted to a PIL image contains values outside the range [0, 1], got [) r-r uint8Zallcloser,intallr"minmaxr do_rescaler'r'r(_rescale_for_pil_conversionys, r7zPIL.Image.Imagez torch.Tensorz tf.Tensorz jnp.ndarray)rr6rcCsttdgt|tjjr|St|s.t|r8|}n2t|rLt |}nt|t j sjt d t|t|tj}|jddkrt j|ddn|}|durt|n|}|rt|d}|t j}tj|S)a Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if needed. Args: image (`PIL.Image.Image` or `numpy.ndarray` or `torch.Tensor` or `tf.Tensor`): The image to convert to the `PIL.Image` format. do_rescale (`bool`, *optional*): Whether or not to apply the scaling factor (to make pixel values integers between 0 and 255). Will default to `True` if the image type is a floating type and casting to `int` would result in a loss of precision, and `False` otherwise. Returns: `PIL.Image.Image`: The converted image. visionz"Input image type not supported: {}rZaxisNr/)r to_pil_imagerPILImagerrnumpyrr arrayr!r"r&r#r)rr%shapeZsqueezer7r.r,r0Z fromarrayr5r'r'r(r;s         r;T) input_imagesizedefault_to_squaremax_sizerc Cst|ttfr@t|dkr"t|St|dkr8|d}ntd|rL||fSt|\}}||krh||fn||f\}}|}|t|||} } |dur||krtd|d|| |krt|| | |} } ||kr| | fS| | fS)a  Find the target (height, width) dimension of the output image after resizing given the input image and the desired size. Args: input_image (`np.ndarray`): The image to resize. size (`int` or `Tuple[int, int]` or List[int] or Tuple[int]): The size to use for resizing the image. If `size` is a sequence like (h, w), output size will be matched to this. If `size` is an int and `default_to_square` is `True`, then image will be resized to (size, size). If `size` is an int and `default_to_square` is `False`, then 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). default_to_square (`bool`, *optional*, defaults to `True`): How to convert `size` when it is a single int. If set to `True`, the `size` will be converted to a square (`size`,`size`). If set to `False`, will replicate [`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize) with support for resizing only the smallest edge and providing an optional `max_size`. max_size (`int`, *optional*): The maximum allowed for the longer edge of the resized image: if the longer edge of the image is greater than `max_size` after being resized according to `size`, then the image is resized again so that the longer edge is equal to `max_size`. As a result, `size` might be overruled, i.e the smaller edge may be shorter than `size`. Only used if `default_to_square` is `False`. Returns: `tuple`: The target (height, width) dimension of the output image after resizing. rrrz7size must have 1 or 2 elements if it is a list or tupleNz max_size = zN must be strictly greater than the requested size for the smaller edge size = )rtuplelistlenr"r r1) rArBrCrDheightwidthshortlongZrequested_new_shortZ new_shortZnew_longr'r'r(get_resize_output_image_sizes,"    rLr)rBresample reducing_gapr+ return_numpyrc Csttdg|dur|ntj}t|dks2td|durBt|n|}d}t|tj j slt |}t ||d}|\}}|j||f||d} |rt | } | jdkrt j| dd n| } t| |tjd } |rt| d n| } | S) aB Resizes `image` to `(height, width)` specified by `size` using the PIL library. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to resize. size (`Tuple[int, int]`): The size to use for resizing the image. resample (`int`, *optional*, defaults to `PILImageResampling.BILINEAR`): The filter to user for resampling. reducing_gap (`int`, *optional*): Apply optimization by resizing the image in two steps. The bigger `reducing_gap`, the closer the result to the fair resampling. See corresponding Pillow documentation for more details. data_format (`ChannelDimension`, *optional*): The channel dimension format of the output image. If unset, will use the inferred format from the input. return_numpy (`bool`, *optional*, defaults to `True`): Whether or not to return the resized image as a numpy array. If False a `PIL.Image.Image` object is returned. Returns: `np.ndarray`: The resized image. r8Nrzsize must have 2 elementsF)r6)rMrNr9r:)rp?)rresizerZBILINEARrGr"r rr<r=r7r;r r?ndimZ expand_dimsr)rr%r.) rrBrMrNr+rOr6rHrIZ resized_imager'r'r(rQs&    rQ)rmeanstdr+rcCsBttdgt|tjjr:tdtt|}t |dd}t|t j sNt dt |}t|}|j|}t|trt||krt d|dt|n |g|}t j||jd}t|trt||krt d |dt|n |g|}t j||jd}|tjkr|||}n|j||j}|d ur:t||n|}|S) a@ Normalizes `image` using the mean and standard deviation specified by `mean` and `std`. image = (image - mean) / std Args: image (`np.ndarray`): The image to normalize. mean (`float` or `Iterable[float]`): The mean to use for normalization. std (`float` or `Iterable[float]`): The standard deviation to use for normalization. data_format (`ChannelDimension`, *optional*): The channel dimension format of the output image. If unset, will use the inferred format from the input. r8fPIL.Image.Image inputs are deprecated and will be removed in v4.26.0. Please use numpy arrays instead.rP)r*zimage must be a numpy arrayzmean must have z$ elements if it is an iterable, got r-zstd must have N)r normalizerr<r=warningswarn FutureWarningr r.r r!r"r r r@rrGr?r-rr%Tr))rrSrTr+input_data_formatZ channel_axisZ num_channelsr'r'r(rWGs8           rW)rrBr+rOrcCs*ttdgt|tjjr@tdtt|}|dur:dn|}n|durLdn|}t|t j snt dt |t|t rt|dkrt dt|}|dur|n|}t|tj}t|\}}|\}} t|t| }} ||d} | |} || d} | | } | d krJ| |krJ| d krJ| |krJ|d | | | | f}t||}|St||}t| |}|jdd ||f}t j||d }||d}||}||d}||}||d ||||f<| |7} | |7} | |7} | |7} |d td | t|| td | t|| f}t||}|s&t|}|S) a Crops the `image` to the specified `size` using a center crop. Note that if the image is too small to be cropped to the size given, it will be padded (so the returned result will always be of size `size`). Args: image (`np.ndarray`): The image to crop. size (`Tuple[int, int]`): The target size for the cropped image. data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format for the output image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. If unset, will use the inferred format of the input image. return_numpy (`bool`, *optional*): Whether or not to return the cropped image as a numpy array. Used for backwards compatibility with the previous ImageFeatureExtractionMixin method. - Unset: will return the same type as the input image. - `True`: will return a numpy array. - `False`: will return a `PIL.Image.Image` object. Returns: `np.ndarray`: The cropped image. r8rUNFTrrzOsize must have 2 elements representing the height and width of the output imager.)r@)r center_croprr<r=rXrYrZr r r!r"r#rrGr r)rr$r r1r4r@Z zeros_liker3r;)rrBr+rOr\Zoutput_data_formatZ orig_heightZ orig_widthZ crop_heightZ crop_widthtopZbottomleftrightZ new_heightZ new_widthZ new_shapeZ new_imageZtop_padZ bottom_padZleft_padZ right_padr'r'r(r^sZ      (     . r^) bboxes_centerrcCsL|d\}}}}tj|d||d||d||d|gdd}|S)Nr9?ZdimZunbindtorchstack)rbcenter_xcenter_yrIrHZ bbox_cornersr'r'r(_center_to_corners_format_torchs *rjcCsH|j\}}}}tj|d||d||d||d|gdd}|S)Nrcr9r:r[r rgrbrhrirIrHbboxes_cornersr'r'r(_center_to_corners_format_numpys *rncCsPtj|dd\}}}}tj|d||d||d||d|gdd}|S)Nr9r:rctfZunstackrgrlr'r'r(_center_to_corners_format_tfs *rqcCsJt|rt|St|tjr$t|St|r4t|Stdt |dS)a| Converts bounding boxes from center format to corners format. center format: contains the coordinate for the center of the box and its width, height dimensions (center_x, center_y, width, height) corners format: contains the coodinates for the top-left and bottom-right corners of the box (top_left_x, top_left_y, bottom_right_x, bottom_right_y) Unsupported input type N) rrjrr r!rnrrqr"r#)rbr'r'r(center_to_corners_formats  rs)rmrcCsD|d\}}}}||d||d||||g}tj|ddS)Nr9rrdre)rm top_left_x top_left_ybottom_right_xbottom_right_ybr'r'r(_corners_to_center_format_torchs  rycCs@|j\}}}}tj||d||d||||gdd}|S)Nrr9r:rkrmrtrurvrwrbr'r'r(_corners_to_center_format_numpy&s   r{cCsHtj|dd\}}}}tj||d||d||||gdd}|S)Nr9r:rrorzr'r'r(_corners_to_center_format_tf4s   r|cCsJt|rt|St|tjr$t|St|r4t|Stdt |dS)a Converts bounding boxes from corners format to center format. corners format: contains the coodinates for the top-left and bottom-right corners of the box (top_left_x, top_left_y, bottom_right_x, bottom_right_y) center format: contains the coordinate for the center of the box and its the width, height dimensions (center_x, center_y, width, height) rrN) rryrr r!r{rr|r"r#)rmr'r'r(corners_to_center_formatBs  r}cCst|tjr|t|jdkr||jtjkr2|tj}|dddddfd|dddddfd|dddddfSt |dd|dd|dS)z* Converts RGB color to unique ID. Nrrir) rr r!rGr@r-r0r,int32r1)colorr'r'r( rgb_to_idYs   JrcCst|tjrb|}tt|jdg}tj|tjd}t dD]}|d|d|f<|d}q@|Sg}t dD]}| |d|d}qn|S)z* Converts unique ID to RGB color. r~rVr.) rr r!copyrErFr@zerosr0rangeappend)Zid_mapZ id_map_copyZ rgb_shapeZrgb_mapir_r'r'r( id_to_rgbds     rc@s eZdZdZdZdZdZdZdS) PaddingModezP Enum class for the different padding modes to use when padding images. constantreflectZ replicate symmetricN)__name__ __module__ __qualname____doc__CONSTANTREFLECT REPLICATE SYMMETRICr'r'r'r(rws rg)rpaddingmodeconstant_valuesr+r\rcsdurtfdd}||}|tjkrL||}tj|d|dnb|tjkrhtj|ddnF|tjkrtj|ddn*|tjkrtj|d dntd ||durt |nS) a Pads the `image` with the specified (height, width) `padding` and `mode`. Args: image (`np.ndarray`): The image to pad. padding (`int` or `Tuple[int, int]` or `Iterable[Tuple[int, int]]`): Padding to apply to the edges of the height, width axes. Can be one of three formats: - `((before_height, after_height), (before_width, after_width))` unique pad widths for each axis. - `((before, after),)` yields same before and after pad for height and width. - `(pad,)` or int is a shortcut for before = after = pad width for all axes. mode (`PaddingMode`): The padding mode to use. Can be one of: - `"constant"`: pads with a constant value. - `"reflect"`: pads with the reflection of the vector mirrored on the first and last values of the vector along each axis. - `"replicate"`: pads with the replication of the last value on the edge of the array along each axis. - `"symmetric"`: pads with the reflection of the vector mirrored along the edge of the array. constant_values (`float` or `Iterable[float]`, *optional*): The value to use for the padding if `mode` is `"constant"`. data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format for the output image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. If unset, will use same as the input image. input_data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format for the input image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. If unset, will use the inferred format of the input image. Returns: `np.ndarray`: The padded image. Ncst|ttfr ||f||ff}nt|trXt|dkrX|d|df|d|dff}nft|trt|dkrt|dtr||f}n8t|trt|dkrt|dtr|}ntd|tjkrdg|Rn g|dR}jdkrdg|Rn|}|S)za Convert values to be in the format expected by np.pad based on the data format. rrrzUnsupported format: )rr) rr1floatrErGr"rr$rR)valuesrr\r'r(_expand_for_data_formats"$ $$z$pad.._expand_for_data_formatr)rrr)rZedgerzInvalid padding mode: ) r rrr padrrrr"r))rrrrr+r\rr'rr(rs +    r)rrcCs,ttdgt|tjjs|S|d}|S)z Converts an image to RGB format. Only converts if the image is of type PIL.Image.Image, otherwise returns the image as is. Args: image (Image): The image to convert. r8ZRGB)rconvert_to_rgbrr<r=convert)rr'r'r(rs  r)rr+rcCsht|}|tjkr&|ddddf}n,|tjkrD|ddddf}ntd||durdt||}|S)a8 Flips the channel order of the image. If the image is in RGB format, it will be converted to BGR and vice versa. Args: image (`np.ndarray`): The image to flip. data_format (`ChannelDimension`, *optional*): The channel dimension format for the output image. Can be one of: - `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `ChannelDimension.LAST`: image in (height, width, num_channels) format. If unset, will use same as the input image. .Nr9zUnsupported channel dimension: )r rr%r$r"r))rr+r\r'r'r(flip_channel_orders   r)N)N)TN)NNNT)N)NN)N)ArXtypingrrrrrr>r Z image_utilsrr r r r r utilsrrrrrZutils.import_utilsrrrrrr<rrfZ tensorflowrpZ jax.numpyZjnpr!strr)float32rr.r7boolr;r1rErLrQrWr^rjrnrqrsryr{r|r}rrrrrrrr'r'r'r(s      &   4 C  F B  a       W