AVhϔ @dZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Zdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddl%m&Z&dd l%m'Z'dd!l%m(Z(dd"l)m*Z*e jVd#e jVd$e jVd%e jVd&e jVd'e jVd(e jVd)e jVd*e jVd+e jVd,d-Z,d.Z-d/Z.dd1Z/d2Z0d3Z1dd4Z2d5Z3dd6Z4d7Z5e*d8e'jldd9Z7e*d:e'jldd;Z8e*dZ9e*d?g=e'jld@Z:dAZ;e*dBe'jldCZ<e*dDe'jldEZ=dFZ>e*dGe'jlddHZ?dIZ@dJZAe*dKdKdLg=e'jlddMZBe*dNe'jldOZCe*dPe'jldQZDdRZEe*dSe'jldTZFe*dUdUdVg=e'jldWZGe*dXg=GdYdZZHe*dXg=Gd[d\ZId]ZJe*d^d_g=e'jleHjd`d`dfdaZLe*d_g=e'jleIjd`d`dfdbZMdcZNe*ddg=e'jleHjd`fdeZOe*dfg=e'jleIjd`fdgZPe*dhe'jldiZQe*dje'je'jlddkZSe*dlg=e'je'jldmZTe*dne'jlddoZUe*dpg=e'jldqZVe*dre'je'jldsZWe*dte'jlduZXe*dve'je'jlddwZYe*dxe'je'jld dyZZe*dze'jldd{Z[e*d|e'jldd}Z\e*d~e'jlddZ]e*dg=e'jldZ^e*de'jlddZ_e*de'jlddZ`e*dg=e'jldZae*de'jld dZbe*de'jlddZce*dg=e'jlddZde*de'jlddZee*ddddg=ddZfddZge*ddddg=e'jlejZhe*ddddg=e'jlejZie*ddddg=e'jlejZje*ddddg=e'jlejZke*ddddg=e'jlejZle*ddddg=e'jlejZme*ddddg=e'jlejZne*dde'jld dZoe*ddddg=e'jlde jdd0fdZqe*de'jlddZre*dg=e'jl d dZse*dg=e'jl d dZte*dg=e'jle&jdd ddZve*de'jldewddfdZxe*de'jldewdddfdZye*de'jldewddfdZzgdgdgdgZ{e*de'jldZ|gdgdgdgZ}e*d«e'jldÄZ~gdĢgdŢgdƢgZe*dǫe'jldȄZgdgdɢgdʢgZe*d˫e'jld̄Zd̈́Ze*dΫe'jlddτZdd҄ZdӄZ ddքZe*d׫e'jl dd؄ZdZe*dګe'jleddddfdۄZe*dܫe'jld݄Ze*dޫe'jld߄Ze*dg=e'jle&jddᬯ ddZe*dg=e'jle&jdd䬯 ddZe*dg=e'jle&jdd笯 ddZe&jdd鬯Ze*dg=ee'jlej"Ze*dg=e'jl ddZe*dg=e'jle&j&ddd ddZej*je_e*dg=e'jl ddZe*dg=e'jl ddZe*de'jldewdd`d0dfdZdZdZdZdZe*de'jldewdd`dd`d`dfdZej<ddewdd`d`dfdZdewdd`dfdZe*dg=e'jlddZe*dg=e'jlddZe*de'jl ddZy(zImplementation of image ops.N)context) def_function)config) constant_op)dtypes)ops) random_seed)tensor) tensor_shape) tensor_util) array_ops)array_ops_stack) check_ops)cond)control_flow_assert)control_flow_case)control_flow_ops) gen_image_ops)math_ops)nn_impl)nn_ops) random_ops) ref_variable)sort_ops)stateless_random_ops) string_ops) variables) while_loop) deprecation)dispatch) numpy_compat) tf_export RandomCropHSVToRGBDrawBoundingBoxesSampleDistortedBoundingBoxSampleDistortedBoundingBoxV2ExtractGlimpseNonMaxSuppressionNonMaxSuppressionV2NonMaxSuppressionWithOverlapsGenerateBoundingBoxProposalsc`t|rtj||ggS|s||gS)aA polymorphic assert, works with tensors and boolean expressions. If `cond` is not a tensor, behave like an ordinary assert statement, except that a empty list is returned. If `cond` is a tensor, return a list containing a single TensorFlow assert op. Args: cond: Something evaluates to a boolean value. May be a tensor. ex_type: The exception class to use. msg: The error message. Returns: A list, containing at most one assert op. ) _is_tensorrAssert)rex_typemsgs T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/image_ops_impl.py_assertr3Hs6  & &tcU 3 44  CL icVt|tjtjfS)zReturns `True` if `x` is a symbolic tensor-like object. Args: x: A python object to check. Returns: `True` if `x` is a `tf.Tensor` or `tf.Variable`, otherwise `False`. ) isinstance tensor_libTensorrVariable)xs r2r.r.`s" A ))9+=+=> ??r4cx|jjr|jjS|jj|j}t j t j||}t||Dcgc] \}}||n| c}}Scc}}w)ahReturns the dimensions of an image tensor. Args: image: A rank-D Tensor. For 3-D of shape: `[height, width, channels]`. rank: The expected rank of the image Returns: A list of corresponding to the dimensions of the input image. Dimensions that are statically known are python integers, otherwise, they are integer scalar tensors. ) get_shapeis_fully_definedas_list with_rankrunstackr shapezip)imagerank static_shape dynamic_shapesds r2_ImageDimensionsrIls __'') ??  $ $ &&??$..t4<<>L#++IOOE,BDIM.1, .N &*aQ]!  s"B6Tc |jjd}|r|j std|zt d|Drtd|z|j s+t jtj|dggSgS#t$rtd|jzwxYw)aAssert that we are working with a properly shaped image. Args: image: 3-D Tensor of shape [height, width, channels] require_static: If `True`, requires that all dimensions of `image` are known and non-zero. Raises: ValueError: if `image.shape` is not a 3-vector. Returns: An empty list, if `image` has fully defined dimensions. Otherwise, a list containing an assert op is returned. z-'image' (shape %s) must be three-dimensional.z)'image' (shape %s) must be fully defined.c3&K|] }|dk( ywrN.0r:s r2 z _Check3DImage..s%Aa%z)all dims of 'image.shape' must be > 0: %sz&all dims of 'image.shape' must be > 0.) r<r? ValueErrorrAr=anyrassert_positiver rCrequire_static image_shapes r2 _Check3DImagerYs"//#--a0KK88: @;N OO%%% @;N OO  % % '!! OOE "    I " D[[! """s B"CcDtjt|d|S)a1Assert that we are working with a properly shaped image. Performs the check statically if possible (i.e. if the shape is statically known). Otherwise adds a control dependency to an assert op that checks the dynamic shape. Args: image: 3-D Tensor of shape [height, width, channels] Raises: ValueError: if `image.shape` is not a 3-vector. Returns: If the shape of `image` could be verified statically, `image` is returned unchanged, otherwise there will be a control dependency added that asserts the correct dynamic shape. FrW)rwith_dependenciesrYrCs r2_Assert3DImager^s#$  + +E%0% 99r4cDtjt|d|S)a6Assert that we are working with a properly shaped image. Performs the check statically if possible (i.e. if the shape is statically known). Otherwise adds a control dependency to an assert op that checks the dynamic shape. Args: image: >= 3-D Tensor of size [*, height, width, depth] Raises: ValueError: if image.shape is not a [>= 3] vector. Returns: If the shape of `image` could be verified statically, `image` is returned unchanged, otherwise there will be a control dependency added that asserts the correct dynamic shape. Fr[)rr\_CheckAtLeast3DImager]s r2_AssertAtLeast3DImageras%$  + +57 @@r4cZ |jj |jjd}n|jjd}|r|j s t dtd|ddDrt d|z|ddj sXtjtj |dddgtjtj|dd gSgS#t$rt d|j zwxYw) aAssert that we are working with a properly shaped image. Args: image: >= 3-D Tensor of size [*, height, width, depth] require_static: If `True`, requires that all dimensions of `image` are known and non-zero. Raises: ValueError: if image.shape is not a [>= 3] vector. Returns: An empty list, if `image` has fully defined dimensions. Otherwise, a list containing an assert op is returned. NrKz6'image' (shape %s) must be at least three-dimensional.'image' must be fully defined.c3&K|] }|dk( ywrMrNrOs r2rQz'_CheckAtLeast3DImage..s*Aa*rRz-inner 3 dims of 'image.shape' must be > 0: %sz*inner 3 dims of 'image.shape' must be > 0.z+'image' must be at least three-dimensional.message) r<ndimsr?with_rank_at_leastrSrAr=rTrrUr assert_greater_equalrDrVs r2r`r`s0" &OO%//2kOO%88;kK88: 7 88*RS)** F ! "" RS  * * ,!! OOE "23 '   && NN5 ! A C   I) " M[[! """s AD"D*cDtjt|d|S)a^Assert that we are working with a properly shaped grayscale image. Performs the check statically if possible (i.e. if the shape is statically known). Otherwise adds a control dependency to an assert op that checks the dynamic shape. Args: image: >= 2-D Tensor of size [*, 1] Raises: ValueError: if image.shape is not a [>= 2] vector or if last dimension is not size 1. Returns: If the shape of `image` could be verified statically, `image` is returned unchanged, otherwise there will be a control dependency added that asserts the correct dynamic shape. Fr[)rr\_CheckGrayscaleImager]s r2_AssertGrayscaleImagerms%&  + +57 @@r4cV |jj |jjd}n|jjd}|r|j s t d|j r|ddk7r t d|j sYtjtj |dddtjtj|dd gSgS#t$rt d|j zwxYw) aAssert that we are working with properly shaped grayscale image. Args: image: >= 2-D Tensor of size [*, 1] require_static: Boolean, whether static shape is required. Raises: ValueError: if image.shape is not a [>= 2] vector or if last dimension is not size 1. Returns: An empty list, if `image` has fully defined dimensions. Otherwise, a list containing an assert op is returned. z>A grayscale image (shape %s) must be at least two-dimensional.rcz5Last dimension of a grayscale image should be size 1.rfrKz3A grayscale image must be at least two-dimensional.) r<rhr?rirSrAr=r assert_equalr rjrDrVs r2rlrls7 &OO%//2kOO%88;kK88: 7 88!!#2! N OO  % % ' OOE "2 & K M && NN5 ! I K   I) 7 (*/++6 777s AD"D(c|j}|tjk(r|jgd|S|j||S)zSet the shape to 3 dimensional if we don't know anything else. Args: image: original image size result: flipped or transformed image Returns: An image whose shape is at least (None, None, None). )NNN)r<r unknown_shape set_shape)rCresultrXs r2fix_image_flip_shaperw>sL!+L..00 '( - [! -r4zimage.random_flip_up_downchtjtj|}t |d|dS)aRandomly flips an image vertically (upside down). With a 1 in 2 chance, outputs the contents of `image` flipped along the first dimension, which is `height`. Otherwise, output the image as-is. When passing a batch of images, each image will be randomly flipped independent of other images. Example usage: >>> image = np.array([[[1], [2]], [[3], [4]]]) >>> tf.image.random_flip_up_down(image, 3).numpy().tolist() [[[3], [4]], [[1], [2]]] Randomly flip multiple images. >>> images = np.array( ... [ ... [[[1], [2]], [[3], [4]]], ... [[[5], [6]], [[7], [8]]] ... ]) >>> tf.image.random_flip_up_down(images, 4).numpy().tolist() [[[[3], [4]], [[1], [2]]], [[[5], [6]], [[7], [8]]]] For producing deterministic results given a `seed` value, use `tf.image.stateless_random_flip_up_down`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. seed: A Python integer. Used to create a random seed. See `tf.compat.v1.set_random_seed` for behavior. Returns: A tensor of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. seedrrandom_flip_up_down functoolspartialrrandom_uniform _random_fliprCrz random_funcs r2r{r{Qs/V!!*";";$G+ eQ -B CCr4zimage.random_flip_left_rightchtjtj|}t |d|dS)aRandomly flip an image horizontally (left to right). With a 1 in 2 chance, outputs the contents of `image` flipped along the second dimension, which is `width`. Otherwise output the image as-is. When passing a batch of images, each image will be randomly flipped independent of other images. Example usage: >>> image = np.array([[[1], [2]], [[3], [4]]]) >>> tf.image.random_flip_left_right(image, 5).numpy().tolist() [[[2], [1]], [[4], [3]]] Randomly flip multiple images. >>> images = np.array( ... [ ... [[[1], [2]], [[3], [4]]], ... [[[5], [6]], [[7], [8]]] ... ]) >>> tf.image.random_flip_left_right(images, 6).numpy().tolist() [[[[2], [1]], [[4], [3]]], [[[5], [6]], [[7], [8]]]] For producing deterministic results given a `seed` value, use `tf.image.stateless_random_flip_left_right`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. seed: A Python integer. Used to create a random seed. See `tf.compat.v1.set_random_seed` for behavior. Returns: A tensor of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. ryrqrandom_flip_left_rightr|rs r2rrs/X!!*";";$G+ eQ -E FFr4z&image.stateless_random_flip_left_right)v1chtjtj|}t |d|dS)aRandomly flip an image horizontally (left to right) deterministically. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). Example usage: >>> image = np.array([[[1], [2]], [[3], [4]]]) >>> seed = (2, 3) >>> tf.image.stateless_random_flip_left_right(image, seed).numpy().tolist() [[[2], [1]], [[4], [3]]] Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) Returns: A tensor of the same type and shape as `image`. ryrq stateless_random_flip_left_rightr}r~rstateless_random_uniformrrs r2rrs92!!33$@+  Q ? AAr4z#image.stateless_random_flip_up_downchtjtj|}t |d|dS)aRandomly flip an image vertically (upside down) deterministically. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). Example usage: >>> image = np.array([[[1], [2]], [[3], [4]]]) >>> seed = (2, 3) >>> tf.image.stateless_random_flip_up_down(image, seed).numpy().tolist() [[[3], [4]], [[1], [2]]] Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) Returns: A tensor of the same type and shape as `image`. ryrstateless_random_flip_up_downrrs r2rrs72!!33$@+  Q < >>r4ctjd|g5tjdtj }fd}fd}|j It j}tjtj|d||cdddS|j dk(r|cdddS|j dk(r|cdddStd|z#1swYyxYw) a`Randomly (50% chance) flip an image along axis `flip_index`. Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. flip_index: Dimension along which to flip the image. Vertical is 0, Horizontal is 1. random_func: partial function for calling either stateful or stateless random ops with `seed` parameter specified. scope_name: Name of the scope in which the ops are added. Returns: A tensor of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. NrCnamecgdd}tj|d}tj|fdfd}t |S)Nr?rAminvalmaxval?c2tjgSNr reverse flip_indexrCsr2z/_random_flip..f_rank3.. s)##EJ<8r4cSrrNr]sr2rz/_random_flip..f_rank3.. s%r4r)rlesstf_condrrw)uniform_random mirror_condrvrrCrscopes r2f_rank3z_random_flip..f_rank3sJ"AcBnMM."5k||  8  f "% 00r4c 6tjd}|gdd}tjtj||dddg}tj |j }tjdzg}||zd|z zzS)Nrrrrq)r rArroundreshapecastdtyper) batch_sizerflips flipped_inputrrCrs r2f_rank4z_random_flip..f_rank4s??5)!,j"*aLnnn   NZAq,A BDemmE5;;/e'' Q/?@m ] "a%i5%8 88r4rK6'image' (shape %s) must have either 3 or 4 dimensions. r name_scopeconvert_to_tensorrar<rhr rDrrrequalrS) rCrr scope_namerArrrDrs ``` @r2rrs$ ~~dJ0!NE  ! !%g 6E !% (E OO E19 {{ ^^E "d \\(..q17G D5!N!N6 {{a Y9!N!N:   Y=!N!N@  Du L NNA!N!NsB D4DD2DD zimage.flip_left_rightct|ddS)aFlip an image horizontally (left to right). Outputs the contents of `image` flipped along the width dimension. See also `tf.reverse`. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.flip_left_right(x) Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. Returns: A tensor of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. rqflip_left_right_flipr]s r2rr$s@ ua* ++r4zimage.flip_up_downct|ddS)aFlip an image vertically (upside down). Outputs the contents of `image` flipped along the height dimension. See also `reverse()`. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.flip_up_down(x) Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. Returns: A `Tensor` of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. r flip_up_downrr]s r2rrGs@ ua ((r4ctjd|g5tjdtj }fd}fd}|j It j}tjtj|d||cdddS|j dk(r|cdddS|j dk(r|cdddStd|z#1swYyxYw) aFlip an image either horizontally or vertically. Outputs the contents of `image` flipped along the dimension `flip_index`. See also `reverse()`. Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. flip_index: 0 For vertical, 1 for horizontal. scope_name: string, scope name. Returns: A `Tensor` of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. NrCrcFttjgSr)rwr rrsr2rz_flip..f_rank3s !%):):5:,)O PPr4c8tjdzgS)Nrqrrsr2rz_flip..f_rank4s   uzA~&6 77r4rKrz5'image' (shape %s)must have either 3 or 4 dimensions.r)rCrrrArrrDs`` r2rrjs& ~~dJ0M  ! !%g 6E !% (E OO EQ8 {{ ^^E "d \\(..q17G DMM   YMM   Y#MM&  Ce K MM'MMsB C;/C;C;-C;;Dz image.rot90ctj|dg5tjdttjtj dj jdtjdj }|jWtj}fd }fd }tjtj|d ||cdddS|jd k(rt!cdddS|jdk(rt#cdddSt%d |z#1swYyxYw) aRotate image(s) by 90 degrees. For example: >>> a=tf.constant([[[1],[2]], ... [[3],[4]]]) >>> # rotating `a` counter clockwise by 90 degrees >>> a_rot=tf.image.rot90(a) >>> print(a_rot[...,0].numpy()) [[2 4] [1 3]] >>> # rotating `a` counter clockwise by 270 degrees >>> a_rot=tf.image.rot90(a, k=3) >>> print(a_rot[...,0].numpy()) [[3 1] [4 2]] >>> # rotating `a` clockwise by 180 degrees >>> a_rot=tf.image.rot90(a, k=-2) >>> print(a_rot[...,0].numpy()) [[4 3] [2 1]] Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. k: A scalar integer tensor. The number of times the image(s) are rotated by 90 degrees. name: A name for this operation (optional). Returns: A rotated tensor of the same type and shape as `image`. Raises: ValueError: if the shape of `image` not supported. rot90rCrkrrrrNctSr) _rot90_3DrCrrsr2rzrot90..f_rank35))r4ctSr) _rot90_4Drsr2rzrot90..f_rank4rr4rKr)rrrrarint32r<assert_has_rankrmodrhr rDrrrrrrS)rCrrrArDrrrs`` @r2rrsCN ~~dGeQZ0NE  ! !%g 6E !% (E av||#>AKKM!!!$ QA OO E {{ ^^E "d**\\(..q17G D#NN$   ua ''NN(   ua '+NN.  Du L NN/NNsC'E&E&3E&E&&E/c6fd}fd}fd}tj|d|ftj|d|ftj|d|fg}tj|fdd| }|j d d j dg|S) aDRotate image counter-clockwise by 90 degrees `k` times. Args: image: 3-D Tensor of shape `[height, width, channels]`. k: A scalar integer. The number of times the image is rotated by 90 degrees. name_scope: A valid TensorFlow name scope. Returns: A 3-D tensor of the same type and shape as `image`. c^tjtjdggdS)Nrqrqrror transpose reverse_v2r]sr2_rot90z_rot90_3D.._rot90s%   y33EA3? KKr4c4tjddgS)Nrrqr rr]sr2_rot180z_rot90_3D.._rot180s   1v ..r4c^tjtjgddgS)Nrrqr rrr]sr2_rot270z_rot90_3D.._rot270s%    3 3E9 Es KKr4rqrorKcSrrNr]sr2rz_rot90_3D..sUr4Tdefault exclusiverN)rrrcaserur<)rCrrrrrcasesrvs` r2rrsL/L NN1a & )HNN1a,@'+J NN1a ' * ,%  ! ! ]d E&D$ 1! 456 -r4cBfd}fd}fd}tj|d|ftj|d|ftj|d|fg}tj|fdd| }|j }|j |d d d |dg|S) aYRotate batch of images counter-clockwise by 90 degrees `k` times. Args: images: 4-D Tensor of shape `[height, width, channels]`. k: A scalar integer. The number of times the images are rotated by 90 degrees. name_scope: A valid TensorFlow name scope. Returns: A 4-D `Tensor` of the same type and shape as `images`. c^tjtjdggdS)NrorrorqrKrimagessr2rz_rot90_4D.._rot90s%   y33FQC@, OOr4c4tjddgS)Nrqrorrsr2rz_rot90_4D.._rot180s   A //r4c^tjtjgddgS)Nrrorrsr2rz_rot90_4D.._rot270s%    3 3FL IA3 OOr4rqrorKcSrrNrsr2rz_rot90_4D..sVr4TrrN)rrrrr<ru) rrrrrrrrvrAs ` r2rrsP0P NN1a & )HNN1a,@'+J NN1a ' * ,%  ! ! ^t* F&    %E!HdD%(34 -r4zimage.transposezimage.transpose_imagecZtjdg5tjdtj }|j Ut j}fd}fd}tjtj|d||cdddS|j dk(r#t jgdcdddS|j d k(r#t jgd cdddStd |z#1swYyxYw) aTranspose image(s) by swapping the height and width dimension. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.transpose(x) Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. name: A name for this operation (optional). Returns: If `image` was 4-D, a 4-D float Tensor of shape `[batch, width, height, channels]` If `image` was 3-D, a 3-D float Tensor of shape `[width, height, channels]` Raises: ValueError: if the shape of `image` not supported. Usage Example: >>> image = [[[1, 2], [3, 4]], ... [[5, 6], [7, 8]], ... [[9, 10], [11, 12]]] >>> image = tf.constant(image) >>> tf.image.transpose(image) rrCrNc8tjgdS)Nrrr rrCrsr2rztranspose..f_rank3Ks""5)$??r4c8tjgdS)Nrrrrsr2rztranspose..f_rank4Ns""5,TBBr4rKrrrr)rrrrar<rhr rDrrrrrrS)rCrrArDrrs`` r2rrs^ ~~dK%1N  ! !%g 6E !% (E OO E {{ ^^E "d@C\\(..q17G DNN      =NN     4 @#NN&  Du L NN'NNsB D!/(D!!(D!D!!D*zimage.central_cropc tjdd|g5tj|d}tj|}|%|dks|dkDr t d|dk(rL|cdddSt tj|dkD|dkt d}tj||}t||jj}|dk7r|d k7rt d j|d }|dk(r,||d \}}||d \}} |jd} n>|jd } ||d \}}||d\}} |jd} |xs|du}| xs|du} |rttj|t j"} tj| | tj|t j"zz dz t j$} nt'|} t)| | |zz dz } | rttj|t j"}tj||tj|t j"zz dz t j$}nt'|}t)|||zz dz }|| dzz }||dzz }|dk(r1t+j,| |d g}t+j,||dg}n2t+j,d | |d g}t+j,d||dg}t/j0|||}|dk(r|j3|rdn|| rdn|| gn|j3 |rdn|| rdn|| g|cdddS#1swYyxYw)aCrop the central region of the image(s). Remove the outer parts of an image but retain the central region of the image along each dimension. If we specify `central_fraction = 0.5`, this function returns the region marked with "X" in the below diagram. The larger the value of `central_fraction`, the larger the dimension of the region to be cropped and retained. -------- | | | XXXX | | XXXX | | | where "X" is the central 50% of the image. -------- This function works on either a single image (`image` is a 3-D Tensor), or a batch of images (`image` is a 4-D Tensor). Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0], ... [7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]], ... [[13.0, 14.0, 15.0], ... [16.0, 17.0, 18.0], ... [19.0, 20.0, 21.0], ... [22.0, 23.0, 24.0]], ... [[25.0, 26.0, 27.0], ... [28.0, 29.0, 30.0], ... [31.0, 32.0, 33.0], ... [34.0, 35.0, 36.0]], ... [[37.0, 38.0, 39.0], ... [40.0, 41.0, 42.0], ... [43.0, 44.0, 45.0], ... [46.0, 47.0, 48.0]]] >>> tf.image.central_crop(x, 0.5) Args: image: Either a 3-D float Tensor of shape [height, width, depth], or a 4-D Tensor of shape [batch_size, height, width, depth]. central_fraction: float (0, 1], fraction of size to crop Raises: ValueError: if central_crop_fraction is not within (0, 1]. Returns: 3-D / 4-D float Tensor, as per the input. N central_croprCrrz¢ral_fraction must be within (0, 1]rKrzK`image` should either be a Tensor with rank = 3 or rank = 4. Had rank = {}.c|jj|j}||dfStj||dfS)NFT)r<dimsvaluer rA)r idxrEs r2_get_dimzcentral_crop.._get_dimsK%%',,S177l  !U"" __V $S )4 //r4rrqrorp)rrrr constant_valuerSr3r logical_orrr\rar<rhformatrrfloat64rfloatintrstackr sliceru)rCcentral_fractioncentral_fraction_static assert_opsrDrimg_h dynamic_himg_w dynamic_wimg_dimg_bsimg_hd bbox_h_startimg_wd bbox_w_start bbox_h_size bbox_w_size bbox_begin bbox_sizes r2rr[sr ~~dNUG4W  ! !%g 6E)889IJ* C '+BS+HABB C 'WW   .46F#6M N >@j00UCe% ??  " "D qyTQY 228&, @@ 0 qy!%+eY!%+eYoo"e #f!%+eY!%+eYoo"e>5=I>5=I }}UFNN3f]] FX]]+;V^^LL L  \\lU|f&6,C#CCqHIl}}UFNN3f]] FX]]+;V^^LL L  \\lU|f&6,C#CCqHIl,**K,**K qy"((, a)HIj!''k2(FGi"((!\<)KLj!''[+r(JKi OOE:y 9E qy oo$$e  oo )$$e  oWWWsA M<-LM<<Nzimage.pad_to_bounding_boxc$t|||||dS)aPad `image` with zeros to the specified `height` and `width`. Adds `offset_height` rows of zeros on top, `offset_width` columns of zeros on the left, and then pads the image on the bottom and right with zeros until it has dimensions `target_height`, `target_width`. This op does nothing if `offset_*` is zero and the image already has size `target_height` by `target_width`. Usage Example: >>> x = [[[1., 2., 3.], ... [4., 5., 6.]], ... [[7., 8., 9.], ... [10., 11., 12.]]] >>> padded_image = tf.image.pad_to_bounding_box(x, 1, 1, 4, 4) >>> padded_image Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. offset_height: Number of rows of zeros to add on top. offset_width: Number of columns of zeros to add on the left. target_height: Height of output image. target_width: Width of output image. Returns: If `image` was 4-D, a 4-D float Tensor of shape `[batch, target_height, target_width, channels]` If `image` was 3-D, a 3-D float Tensor of shape `[target_height, target_width, channels]` Raises: ValueError: If the shape of `image` is incompatible with the `offset_*` or `target_*` arguments, or either `offset_height` or `offset_width` is negative. T) check_dims)pad_to_bounding_box_internal)rC offset_height offset_width target_height target_widths r2pad_to_bounding_boxrs$t &   r4c *tjdd|g5tj|d}d}|j}|jdk(rd}t j |d}nW|j.d}t j |d}|jdgd zn|jd k7rtd |zt|d \}} } } ||z | z } ||z | z } |rt|d }|t|dk\td z }|t|dk\tdz }|t| dk\tdz }|t| dk\tdz }tj||}t jtj dd|| || ddgd dg}t j"||}|||| fDcgc]}t%|rdn|}}|j||st j&|dg}|cdddScc}w#1swYyxYw)aPad `image` with zeros to the specified `height` and `width`. Adds `offset_height` rows of zeros on top, `offset_width` columns of zeros on the left, and then pads the image on the bottom and right with zeros until it has dimensions `target_height`, `target_width`. This op does nothing if `offset_*` is zero and the image already has size `target_height` by `target_width`. Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. offset_height: Number of rows of zeros to add on top.Must be 0-D `Tensor` of dtype int32 or int64. Can also a python integer. offset_width: Number of columns of zeros to add on the left.Must be 0-D `Tensor` of dtype int32 or int64. Can also a python integer. target_height: Height of output image.Must be 0-D `Tensor` of dtype int32 or int64. Can also a python integer. target_width: Width of output image.Must be 0-D `Tensor` of dtype int32 or int64. Can also a python integer. check_dims: If True, assert that dimensions are non-negative and in range. In multi-GPU distributed settings, assertions can cause program slowdown. Setting this parameter to `False` avoids this, resulting in faster speed in some situations, with the tradeoff being that some error checking is not happening. Returns: If `image` was 4-D, a 4-D float Tensor of shape `[batch, target_height, target_width, channels]` If `image` was 3-D, a 3-D float Tensor of shape `[target_height, target_width, channels]` Raises: ValueError: If the shape of `image` is incompatible with the `offset_*` or `target_*` arguments, or either `offset_height` or `offset_width` is negative. Not raised if `check_dims` is `False`. NrrCrTrKFrrrrDr[zoffset_height must be >= 0zoffset_width must be >= 0z width must be <= target - offsetz!height must be <= target - offsetroaxis)rrrr<rhr expand_dimsrurSrIr`r3rr\rrrpadr.squeeze)rCr rrrr is_batchrXbatchheightwidthdepthafter_padding_widthafter_padding_heightrpaddingspaddedi padded_shapes r2r r 4s_N ~~d1E7;4  ! !%g 6EH//#KAh##E1-e    "h##E1-e ootfqj!   a   D   #35q"AE65%&5=(=86A'eDjGMQ. 8::jGLA-z799jG/14j>@@jG0A5z?AAj00UCe   q-!5| A  F H ]]5( +F e< 1 1$L \"   qc2f i44VW44sFH 6H .H H  Hzimage.crop_to_bounding_boxc tjdd|g5tj|d}d}|j}|jdk(rd}t j |d}nW|j.d}t j |d}|jdgd zn|jd k7rtd |zt|d }t|d \}} } } |t|dk\td z }|t|dk\tdz }|t|dkDtdz }|t|dkDtdz }|t| ||zk\tdz }|t| ||zk\tdz }tj||}t j|tj d||dgtj t j"|d||t j"|dg} |||| fD cgc]} t%| rdn| }} | j||st j&| dg} | cdddScc} w#1swYyxYw)aCrops an `image` to a specified bounding box. This op cuts a rectangular bounding box out of `image`. The top-left corner of the bounding box is at `offset_height, offset_width` in `image`, and the lower-right corner is at `offset_height + target_height, offset_width + target_width`. Example Usage: >>> image = tf.constant(np.arange(1, 28, dtype=np.float32), shape=[3, 3, 3]) >>> image[:,:,0] # print the first channel of the 3-D tensor >>> cropped_image = tf.image.crop_to_bounding_box(image, 0, 0, 2, 2) >>> cropped_image[:,:,0] # print the first channel of the cropped 3-D tensor Args: image: 4-D `Tensor` of shape `[batch, height, width, channels]` or 3-D `Tensor` of shape `[height, width, channels]`. offset_height: Vertical coordinate of the top-left corner of the bounding box in `image`. Must be 0-D int32 `Tensor` or python integer. offset_width: Horizontal coordinate of the top-left corner of the bounding box in `image`. Must be 0-D int32 `Tensor` or python integer. target_height: Height of the bounding box. Must be 0-D int32 `Tensor` or python integer. target_width: Width of the bounding box. Must be 0-D int32 `Tensor` or python integer. Returns: If `image` was 4-D, a 4-D `Tensor` of shape `[batch, target_height, target_width, channels]`. If `image` was 3-D, a 3-D `Tensor` of shape `[target_height, target_width, channels]`. It has the same dtype with `image`. Raises: ValueError: `image` is not a 3-D or 4-D `Tensor`. ValueError: `offset_width < 0` or `offset_height < 0`. ValueError: `target_width <= 0` or `target_height <= 0`. ValueError: `width < offset_width + target_width` or `height < offset_height + target_height`. Ncrop_to_bounding_boxrCrTrKFrrrr[rzoffset_width must be >= 0.zoffset_height must be >= 0.target_width must be > 0.target_height must be > 0.z!width must be >= target + offset.z"height must be >= target + offset.r)rrrr<rhr rrurSr`rIr3rr\rrrrAr.r)rCr rrrrrXrrrrrcroppedr" cropped_shapes r2r%r%sf ~~d2UG<5  ! !%g 6EH//#KAh##E1-e    "h##E1-e ootfqj!   a   D   &eEBJ"25q"AE65%',!+Z688J'-1,j799J',*J577J'-!+Z688J'%L<$?@*=??J'&]]%BCZ>@@J  . .z5 AEoo q-qAB OOE "1 %   OOE "1 % ' ()G e< 1 1$M m$ !!'4g k55XY55sG'II.IIIzimage.resize_with_crop_or_padz#image.resize_image_with_crop_or_padc tjdd|g5tj|d}|j}d}|jdk(rd}t j |d}nW|j.d}t j |d}|jdgd zn|jd k7rtd |zt|d }|t|dkDtd z }|t|dkDtd z }tj||}t|rtj||}t|rtj||}d}d}d}t|d \} } } } || z } || dzd} || dzd}|| z }|| dzd}||dzd}t||| ||| ||| }t!|||||}|jj tdt|d \} }}} g}|t|||tdz }|t|||tdz }tj||}|st j"|dg}|cdddS#1swYyxYw)aCrops and/or pads an image to a target width and height. Resizes an image to a target width and height by either centrally cropping the image or padding it evenly with zeros. If `width` or `height` is greater than the specified `target_width` or `target_height` respectively, this op centrally crops along that dimension. For example: >>> image = np.arange(75).reshape(5, 5, 3) # create 3-D image input >>> image[:,:,0] # print first channel just for demo purposes array([[ 0, 3, 6, 9, 12], [15, 18, 21, 24, 27], [30, 33, 36, 39, 42], [45, 48, 51, 54, 57], [60, 63, 66, 69, 72]]) >>> image = tf.image.resize_with_crop_or_pad(image, 3, 3) # crop >>> # print first channel for demo purposes; centrally cropped output >>> image[:,:,0] If `width` or `height` is smaller than the specified `target_width` or `target_height` respectively, this op centrally pads with 0 along that dimension. For example: >>> image = np.arange(1, 28).reshape(3, 3, 3) # create 3-D image input >>> image[:,:,0] # print first channel just for demo purposes array([[ 1, 4, 7], [10, 13, 16], [19, 22, 25]]) >>> image = tf.image.resize_with_crop_or_pad(image, 5, 5) # pad >>> # print first channel for demo purposes; we should see 0 paddings >>> image[:,:,0] Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. target_height: Target height. target_width: Target width. Raises: ValueError: if `target_height` or `target_width` are zero or negative. Returns: Cropped and/or padded image. If `images` was 4-D, a 4-D float Tensor of shape `[batch, new_height, new_width, channels]`. If `images` was 3-D, a 3-D float Tensor of shape `[new_height, new_width, channels]`. Nresize_image_with_crop_or_padrCrTrKFrrrr[r&r'crt|s t|rtj||St||Srr.rmaximummaxr:ys r2max_z+resize_image_with_crop_or_pad..max_`. A*Q-1%%1ayr4crt|s t|rtj||St||Sr)r.rminimumminr0s r2min_z+resize_image_with_crop_or_pad..min_fr3r4cdt|s t|rtj||S||k(Sr)r.rrr0s r2equal_z-resize_image_with_crop_or_pad..equal_ls) A*Q-~~a##Av r4rrozresized contains no shape.zresized height is not correct.zresized width is not correct.r)rrrr<rhr rrurSr`r3rr\r.rIr%rr)rCrrrXrrr2r7r9_rr width_diffoffset_crop_widthoffset_pad_width height_diffoffset_crop_heightoffset_pad_heightr(resizedresized_height resized_widths r2r+r+sF ~~d;eWEW  ! !%g 6E//#KHAh##E1-e    "h##E1-e ootfqj!   a   D   &eEBJ',*J577J'-!+Z688J  . .z5 AE- &88 m%m,%77 8DFl   +5q9Avua%Jj[A-q1J!OQ/&(K{la/3[A-q1#5*<>O#' v#>#' e#<>G "'+<>N"/?G  ( 3 44*:7*K'A~}aJ'~}-z(**J'}l+Z'))J00WEG !!'4g oWWWs IJJ zimage.ResizeMethodc eZdZdZdZdZdZdZy)ResizeMethodV1z"See `v1.image.resize` for details.rrqrorKN)__name__ __module__ __qualname____doc__BILINEARNEAREST_NEIGHBORBICUBICAREArNr4r2rErEs* ( ' $r4rEc0eZdZdZdZdZdZdZdZdZ dZ d Z y ) ResizeMethodz"See `tf.image.resize` for details.bilinearnearestbicubicarealanczos3lanczos5gaussian mitchellcubicN) rFrGrHrIrJrKrLrMLANCZOS3LANCZOS5GAUSSIAN MITCHELLCUBICrNr4r2rOrOs.* ( ' $ ( ( (!-r4rOc tj|d||g5tj|d}|jj t dd}|jjdk(rd}t j|d }n(|jjd k7r t d |jj\}}} } tj|tjd }|jjdgs t d|rt|d \}} } }tj|d tj tj| tj z } tj|dtj tj| tj z } tj"| | }tjtj$|tj| tj ztj}tjtj$|tj| tj ztj}tj||gtjd }t'j(|}t+j,|d j.}t+j,|dj.}|rEt1d|| ||fDr/| |k(r*||k(r%|st j2|d g}|cdddS|||}|j5d||dg|st j2|d g}|cdddS#tt f$r t d wxYw#1swYyxYw)z2Core functionality for v1 and v2 resize functions.resizerrNz'images' contains no shape.TrKFrrz,'images' must have either 3 or 4 dimensions.sizez!'size' must be a 1-D int32 Tensorroz@'size' must be a 1-D Tensor of 2 elements: new_height, new_widthrrqc3$K|]}|du ywrrNrOs r2rQz(_resize_images_common..s#E   #Esr)rrrr<rhrSr rr>rr TypeErroris_compatible_withrIrrfloat32r5rr constant_value_as_shaper dimension_at_indexrallrru)r resizer_fnr^preserve_aspect_ratiorskip_resize_if_samerr:rrcurrent_height current_widthscale_factor_heightscale_factor_width scale_factorscaled_height_constscaled_width_constsize_const_as_shapenew_height_constnew_width_consts r2_resize_images_commonrssu ~~dHvtn5H  " "6 9F ' 6 77H 1$h$$VQ/f     ! !Q & G HH **,446Avua>  " "4F Cd >>  . .s 3 / 00, s#E!5*:FC#E E _ $3C)C ""64 }HH@ %F d,otDE   qc2f QHH z "> < ==>!HHs+CO &N.I O +9O .O  O  Ozimage.resize_imagesz image.resizeFc4fd}t|||||dS)a] Resize `images` to `size` using the specified `method`. Resized images will be distorted if their original aspect ratio is not the same as `size`. To avoid distortions see `tf.image.resize_with_pad` or `tf.image.resize_with_crop_or_pad`. The `method` can be one of: * `tf.image.ResizeMethod.BILINEAR`: [Bilinear interpolation.]( https://en.wikipedia.org/wiki/Bilinear_interpolation) * `tf.image.ResizeMethod.NEAREST_NEIGHBOR`: [ Nearest neighbor interpolation.]( https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation) * `tf.image.ResizeMethod.BICUBIC`: [Bicubic interpolation.]( https://en.wikipedia.org/wiki/Bicubic_interpolation) * `tf.image.ResizeMethod.AREA`: Area interpolation. The return value has the same type as `images` if `method` is `tf.image.ResizeMethod.NEAREST_NEIGHBOR`. It will also have the same type as `images` if the size of `images` can be statically determined to be the same as `size`, because `images` is returned in this case. Otherwise, the return value has type `float32`. Args: images: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. size: A 1-D int32 Tensor of 2 elements: `new_height, new_width`. The new size for the images. method: ResizeMethod. Defaults to `tf.image.ResizeMethod.BILINEAR`. align_corners: bool. If True, the centers of the 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels. Defaults to `False`. preserve_aspect_ratio: Whether to preserve the aspect ratio. If this is set, then `images` will be resized to a size that fits in `size` while preserving the aspect ratio of the original image. Scales up the image if `size` is bigger than the current size of the `image`. Defaults to False. name: A name for this operation (optional). Raises: ValueError: if the shape of `images` is incompatible with the shape arguments to this function ValueError: if `size` has invalid shape or type. ValueError: if an unsupported resize method is specified. Returns: If `images` was 4-D, a 4-D float Tensor of shape `[batch, new_height, new_width, channels]`. If `images` was 3-D, a 3-D float Tensor of shape `[new_height, new_width, channels]`. c(tjk(stjk(rtj||Stj k(stj k(rtj ||Stjk(stjk(rtj||Stjk(stjk(rtj||Stdj)z=Legacy resize core function, passed to _resize_images_common. align_corners$Resize method is not implemented: {}) rErJrOrresize_bilinearrKresize_nearest_neighborrLresize_bicubicrM resize_arearSr)images_tnew_sizerwmethods r2 resize_fnz resize_images..resize_fn9s (((Fl6K6K,K  * * HM;; N33 3 L11 1  2 2 HM;; >)) )V|7K7K-K  ) ) HM;; >&& &&L4E4E*E  & & HM;; =DDVL MMr4Trgrrhrs)rr^rrwrgrrs `` r2 resize_imagesrs+vN$   1    r4c4fd}t|||||dS)adResize `images` to `size` using the specified `method`. Resized images will be distorted if their original aspect ratio is not the same as `size`. To avoid distortions see `tf.image.resize_with_pad`. >>> image = tf.constant([ ... [1,0,0,0,0], ... [0,1,0,0,0], ... [0,0,1,0,0], ... [0,0,0,1,0], ... [0,0,0,0,1], ... ]) >>> # Add "batch" and "channels" dimensions >>> image = image[tf.newaxis, ..., tf.newaxis] >>> image.shape.as_list() # [batch, height, width, channels] [1, 5, 5, 1] >>> tf.image.resize(image, [3,5])[0,...,0].numpy() array([[0.6666667, 0.3333333, 0. , 0. , 0. ], [0. , 0. , 1. , 0. , 0. ], [0. , 0. , 0. , 0.3333335, 0.6666665]], dtype=float32) It works equally well with a single image instead of a batch of images: >>> tf.image.resize(image[0], [3,5]).shape.as_list() [3, 5, 1] When `antialias` is true, the sampling filter will anti-alias the input image as well as interpolate. When downsampling an image with [anti-aliasing]( https://en.wikipedia.org/wiki/Spatial_anti-aliasing) the sampling filter kernel is scaled in order to properly anti-alias the input image signal. `antialias` has no effect when upsampling an image: >>> a = tf.image.resize(image, [5,10]) >>> b = tf.image.resize(image, [5,10], antialias=True) >>> tf.reduce_max(abs(a - b)).numpy() 0.0 The `method` argument expects an item from the `image.ResizeMethod` enum, or the string equivalent. The options are: * `bilinear`: [Bilinear interpolation.]( https://en.wikipedia.org/wiki/Bilinear_interpolation) If `antialias` is true, becomes a hat/tent filter function with radius 1 when downsampling. * `lanczos3`: [Lanczos kernel]( https://en.wikipedia.org/wiki/Lanczos_resampling) with radius 3. High-quality practical filter but may have some ringing, especially on synthetic images. * `lanczos5`: [Lanczos kernel] ( https://en.wikipedia.org/wiki/Lanczos_resampling) with radius 5. Very-high-quality filter but may have stronger ringing. * `bicubic`: [Cubic interpolant]( https://en.wikipedia.org/wiki/Bicubic_interpolation) of Keys. Equivalent to Catmull-Rom kernel. Reasonably good quality and faster than Lanczos3Kernel, particularly when upsampling. * `gaussian`: [Gaussian kernel]( https://en.wikipedia.org/wiki/Gaussian_filter) with radius 3, sigma = 1.5 / 3.0. * `nearest`: [Nearest neighbor interpolation.]( https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation) `antialias` has no effect when used with nearest neighbor interpolation. * `area`: Anti-aliased resampling with area interpolation. `antialias` has no effect when used with area interpolation; it always anti-aliases. * `mitchellcubic`: Mitchell-Netravali Cubic non-interpolating filter. For synthetic images (especially those lacking proper prefiltering), less ringing than Keys cubic kernel but less sharp. Note: Near image edges the filtering kernel may be partially outside the image boundaries. For these pixels, only input pixels inside the image will be included in the filter sum, and the output value will be appropriately normalized. The return value has type `float32`, unless the `method` is `ResizeMethod.NEAREST_NEIGHBOR`, then the return dtype is the dtype of `images`: >>> nn = tf.image.resize(image, [5,7], method='nearest') >>> nn[0,...,0].numpy() array([[1, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 1]], dtype=int32) With `preserve_aspect_ratio=True`, the aspect ratio is preserved, so `size` is the maximum for each dimension: >>> max_10_20 = tf.image.resize(image, [10,20], preserve_aspect_ratio=True) >>> max_10_20.shape.as_list() [1, 10, 10, 1] Args: images: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. size: A 1-D int32 Tensor of 2 elements: `new_height, new_width`. The new size for the images. method: An `image.ResizeMethod`, or string equivalent. Defaults to `bilinear`. preserve_aspect_ratio: Whether to preserve the aspect ratio. If this is set, then `images` will be resized to a size that fits in `size` while preserving the aspect ratio of the original image. Scales up the image if `size` is bigger than the current size of the `image`. Defaults to False. antialias: Whether to use an anti-aliasing filter when downsampling an image. name: A name for this operation (optional). Raises: ValueError: if the shape of `images` is incompatible with the shape arguments to this function ValueError: if `size` has an invalid shape or type. ValueError: if an unsupported resize method is specified. Returns: If `images` was 4-D, a 4-D float Tensor of shape `[batch, new_height, new_width, channels]`. If `images` was 3-D, a 3-D float Tensor of shape `[new_height, new_width, channels]`. cZtjtjtjtjg}fd}tj k(r"r|dSt jdStjk(rt jdStjk(r"r|dSt jdStjk(rt jS|vr|Stdj)z6Resize core function, passed to _resize_images_common.c$tjtjtjt j ddtjz }t j|t jdg|S)NrrqrKro) kernel_type antialias) rrrrbr rArscale_and_translatezeros)rscalerr}r~s r2resize_with_scale_and_translatezLresize_images_v2..resize_fn..resize_with_scale_and_translatest -- 7 -- 1!A6fnn M N  . .    //1#  r4triangleT)half_pixel_centers keyscubicrx)rOrXrYrZr[rJrryrKrzrLr{rMr|rSr)r}r~scale_and_translate_methodsrrrs`` r2rz#resize_images_v2..resize_fns |44l6K6K""# &&& .z::,, h49 9 <00 0  2 2 H77 <'' ' .{;;++ h49 9 <$$ $  & &x :: . . ,V 44 =DDVL MMr4Frr)rr^rrgrrrs ` ` r2resize_images_v2rTs,B'NR   1   !!r4ctjdd|g5tj|d}|j}d}|jdk(rd}t j |d}nW|j.d}t j |d}|jdgd zn|jd k7rtd |zt|d }|t|dkDtd z }|t|dkDtd z }tj||}d}t|d \}} } }tj| t j"} tj| t j"} tj|t j"} tj|t j"}|| |z | | z }| |z }| |z }tjtj$|t j&}tjtj$|t j&}| |z dz }||z dz }tj$|}tj$|}|dtj|t j&}|dtj|t j&}||||g}t)|||||}|jj tdt|d |st j*|dg}|cdddS#1swYyxYw)zACore functionality for v1 and v2 resize_image_with_pad functions.Nresize_image_with_padrCrTrKFrrrr[r&r'crt|s t|rtj||St||Srr-r0s r2r2z+_resize_image_with_pad_common..max_"r3r4rrrozpadded contains no shape.r)rrrr<rhr rrurSr`r3rr\rIrrrrbfloorrrr)rCrrrrXrrr2r:rrf_heightf_widthf_target_heightf_target_widthratioresized_height_floatresized_width_floatrBrCpadding_height padding_widthf_padding_heightf_padding_widthp_heightp_widthrAr!s r2_resize_image_with_pad_commonrs ~~d3eW=E  ! !%g 6E//#KHAh##E1-e    "h##E1-e ootfqj!   a   D   &eEBJ',*J577J'-!+Z688J  . .z5 AE +5q9Avua}}V6>>:HmmE8GmmMHO]])8o+E FE#e+!E/]]+,FLLBNMM*+6<<AM&(<<AN#&99Q>M~~n5nn]3OAx}}%5V\\JKH1hmmO6<<HIG >?G (G]!-/F' 2 33V!$   qc2f KEEEs L%MMzimage.resize_image_with_padc.fd}t||||S)aEResizes and pads an image to a target width and height. Resizes an image to a target width and height by keeping the aspect ratio the same without distortion. If the target dimensions don't match the image dimensions, the image is resized and then padded with zeroes to match requested dimensions. Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. target_height: Target height. target_width: Target width. method: Method to use for resizing image. See `resize_images()` align_corners: bool. If True, the centers of the 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels. Defaults to `False`. Raises: ValueError: if `target_height` or `target_width` are zero or negative. Returns: Resized and padded image. If `images` was 4-D, a 4-D float Tensor of shape `[batch, new_height, new_width, channels]`. If `images` was 3-D, a 3-D float Tensor of shape `[new_height, new_width, channels]`. c"t||S)Nrv)r)imr~rwrs r2 _resize_fnz,resize_image_with_pad_v1.._resize_fnvs Xv] KKr4r)rCrrrrwrs `` r2resize_image_with_pad_v1rRs"HL 'um\'1 33r4zimage.resize_with_padc.fd}t||||S)aResizes and pads an image to a target width and height. Resizes an image to a target width and height by keeping the aspect ratio the same without distortion. If the target dimensions don't match the image dimensions, the image is resized and then padded with zeroes to match requested dimensions. Args: image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. target_height: Target height. target_width: Target width. method: Method to use for resizing image. See `image.resize()` antialias: Whether to use anti-aliasing when resizing. See 'image.resize()'. Raises: ValueError: if `target_height` or `target_width` are zero or negative. Returns: Resized and padded image. If `images` was 4-D, a 4-D float Tensor of shape `[batch, new_height, new_width, channels]`. If `images` was 3-D, a 3-D float Tensor of shape `[new_height, new_width, channels]`. c"t||S)N)r)r)rr~rrs r2rz,resize_image_with_pad_v2.._resize_fns B&I FFr4r)rCrrrrrs `` r2resize_image_with_pad_v2r}s"DG 'um\'1 33r4zimage.per_image_standardizationctjdd|g5}tj|d}t|}t j |t j}t jtj|dd}t j|gdd }t j|gdd }t jt j |t j}t j||}||z}t j|||}|cdddS#1swYyxYw) aLinearly scales each image in `image` to have mean 0 and variance 1. For each 3-D image `x` in `image`, computes `(x - mean) / adjusted_stddev`, where - `mean` is the average of all values in `x` - `adjusted_stddev = max(stddev, 1.0/sqrt(N))` is capped away from 0 to protect against division by 0 when handling uniform images - `N` is the number of elements in `x` - `stddev` is the standard deviation of all values in `x` Example Usage: >>> image = tf.constant(np.arange(1, 13, dtype=np.int32), shape=[2, 2, 3]) >>> image # 3-D tensor >>> new_image = tf.image.per_image_standardization(image) >>> new_image # 3-D tensor with mean ~= 0 and variance ~= 1 Args: image: An n-D `Tensor` with at least 3 dimensions, the last 3 of which are the dimensions of each image. Returns: A `Tensor` with the same shape as `image` and its dtype is `float32`. Raises: ValueError: The shape of `image` has fewer than 3 dimensions. Nper_image_standardizationrCrrre)rpreT)rkeepdims)rrrrarrrrb reduce_prodr rA reduce_mean reduce_stdrsqrtr.divide)rCr num_pixels image_meanstddev min_stddevadjusted_stddevs r2rrsR ~~d7%AU  ! !%g 6E !% (E MM%v~~ 6E%%iooe&zimage.random_brightnesscn|dkr tdtjg| ||}t||S)aAdjust the brightness of images by a random factor. Equivalent to `adjust_brightness()` using a `delta` randomly picked in the interval `[-max_delta, max_delta)`. For producing deterministic results given a `seed` value, use `tf.image.stateless_random_brightness`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: An image or images to adjust. max_delta: float, must be non-negative. This parameter controls the maximum relative change in brightness. seed: A Python integer. Used to create a random seed. See `tf.compat.v1.set_random_seed` for behavior. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.random_brightness(x, 0.2) Returns: The brightness-adjusted image(s). Raises: ValueError: if `max_delta` is negative. rmax_delta must be non-negative.ry)rSrradjust_brightnessrC max_deltarzdeltas r2random_brightnessrs=J] 6 77  # #B ID I% 5% ((r4z!image.stateless_random_brightnesscn|dkr tdtjg| ||}t||S)aAdjust the brightness of images by a random factor deterministically. Equivalent to `adjust_brightness()` using a `delta` randomly picked in the interval `[-max_delta, max_delta)`. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> seed = (1, 2) >>> tf.image.stateless_random_brightness(x, 0.2, seed) Args: image: An image or images to adjust. max_delta: float, must be non-negative. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) Returns: The brightness-adjusted image(s). Raises: ValueError: if `max_delta` is negative. rrrArrrz)rSrrrrs r2stateless_random_brightnessr sAN] 6 77  7 7  z)$ @% 5% ((r4zimage.random_contrastc||kr td|dkr tdtjg|||}t||S)aAdjust the contrast of an image or images by a random factor. Equivalent to `adjust_contrast()` but uses a `contrast_factor` randomly picked in the interval `[lower, upper)`. For producing deterministic results given a `seed` value, use `tf.image.stateless_random_contrast`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: An image tensor with 3 or more dimensions. lower: float. Lower bound for the random contrast factor. upper: float. Upper bound for the random contrast factor. seed: A Python integer. Used to create a random seed. See `tf.compat.v1.set_random_seed` for behavior. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.random_contrast(x, 0.2, 0.5) Returns: The contrast-adjusted image(s). Raises: ValueError: if `upper <= lower` or if `lower < 0`. upper must be > lower.rlower must be non-negative.ry)rSrradjust_contrastrClowerupperrzcontrast_factors r2random_contrastr<sNH e^ - .. QY 2 33--b%TJ/  00r4zimage.stateless_random_contrastc||kr td|dkr tdtjg|||}t||S)aAdjust the contrast of images by a random factor deterministically. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). Args: image: An image tensor with 3 or more dimensions. lower: float. Lower bound for the random contrast factor. upper: float. Upper bound for the random contrast factor. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> seed = (1, 2) >>> tf.image.stateless_random_contrast(x, 0.2, 0.5, seed) Returns: The contrast-adjusted image(s). Raises: ValueError: if `upper <= lower` or if `lower < 0`. rrrr)rSrrrrs r2stateless_random_contrastrjsQH e^ - .. QY 2 33(AA uU7/  00r4zimage.adjust_brightnessctjdd||g5}tj|d}|j}|tj tj fvr|}nt|tj }tj|tj||j|}t||dcdddS#1swYyxYw)aAdjust the brightness of RGB or Grayscale images. This is a convenience method that converts RGB images to float representation, adjusts their brightness, and then converts them back to the original data type. If several adjustments are chained, it is advisable to minimize the number of redundant conversions. The value `delta` is added to all components of the tensor `image`. `image` is converted to `float` and scaled appropriately if it is in fixed-point representation, and `delta` is converted to the same data type. For regular images, `delta` should be in the range `(-1,1)`, as it is added to the image in floating point representation, where pixel values are in the `[0,1)` range. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.adjust_brightness(x, delta=0.1) Args: image: RGB image or images to adjust. delta: A scalar. Amount to add to the pixel values. Returns: A brightness-adjusted tensor of the same shape and type as `image`. NrrCrTsaturate) rrrrrfloat16rbconvert_image_dtyperaddr)rCrr orig_dtype flt_imageadjusteds r2rrsJ ~~d/%@ DD  ! !%g 6EJfnnfnn55i%eV^^>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.adjust_contrast(x, 2.) Args: images: Images to adjust. At least 3-D. contrast_factor: A float multiplier for adjusting contrast. Returns: The contrast-adjusted image or images. Nrrr)rrTr) rrrrrrrbrradjust_contrastv2)rrrr flt_imagesrs r2rrsT ~~d-/1D48  " "6 9FJfnnfnn55j&vv~~>j..O$@H xd CDDDs BB,,B5zimage.adjust_gammactjdd|||g5}tj|d}|j}|tj tj fvr|}nt|tj }t|dk\td}|rtj||}|||zz}t||dcdddS#1swYyxYw) aPerforms [Gamma Correction](http://en.wikipedia.org/wiki/Gamma_correction). on the input image. Also known as Power Law Transform. This function converts the input images at first to float representation, then transforms them pixelwise according to the equation `Out = gain * In**gamma`, and then converts the back to the original data type. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.adjust_gamma(x, 0.2) Args: image : RGB image or images to adjust. gamma : A scalar or tensor. Non-negative real number. gain : A scalar or tensor. The constant multiplier. Returns: A Tensor. A Gamma-adjusted tensor of the same shape and type as `image`. Raises: ValueError: If gamma is negative. Notes: For gamma greater than 1, the histogram will shift towards left and the output image will be darker than the input image. For gamma less than 1, the histogram will shift towards right and the output image will be brighter than the input image. References: [Wikipedia](http://en.wikipedia.org/wiki/Gamma_correction) N adjust_gammarCrrz+Gamma should be a non-negative real number.Tr) rrrrrrrbrr3rSrr\)rCgammagainrrr assert_op adjusted_imgs r2rr sZ ~~dNUE4,@AHT  ! !%g 6EJfnnfnn55i%eV^^>> x = [[[1, 2, 3], [4, 5, 6]], ... [[7, 8, 9], [10, 11, 12]]] >>> x_int8 = tf.convert_to_tensor(x, dtype=tf.int8) >>> tf.image.convert_image_dtype(x_int8, dtype=tf.float16, saturate=False) Converting integer types to floating point types returns normalized floating point values in the range [0, 1); the values are normalized by the `MAX` value of the input dtype. Consider the following two examples: >>> a = [[[1], [2]], [[3], [4]]] >>> a_int8 = tf.convert_to_tensor(a, dtype=tf.int8) >>> tf.image.convert_image_dtype(a_int8, dtype=tf.float32) >>> a_int32 = tf.convert_to_tensor(a, dtype=tf.int32) >>> tf.image.convert_image_dtype(a_int32, dtype=tf.float32) Despite having identical values of `a` and output dtype of `float32`, the outputs differ due to the different input dtypes (`int8` vs. `int32`). This is, again, because the values are normalized by the `MAX` value of the input dtype. Note that converting floating point values to integer type may lose precision. In the example below, an image tensor `b` of dtype `float32` is converted to `int8` and back to `float32`. The final output, however, is different from the original input `b` due to precision loss. >>> b = [[[0.12], [0.34]], [[0.56], [0.78]]] >>> b_float32 = tf.convert_to_tensor(b, dtype=tf.float32) >>> b_int8 = tf.image.convert_image_dtype(b_float32, dtype=tf.int8) >>> tf.image.convert_image_dtype(b_int8, dtype=tf.float32) Scaling up from an integer type (input dtype) to another integer type (output dtype) will not map input dtype's `MAX` to output dtype's `MAX` but converting back and forth should result in no change. For example, as shown below, the `MAX` value of int8 (=127) is not mapped to the `MAX` value of int16 (=32,767) but, when scaled back, we get the same, original values of `c`. >>> c = [[[1], [2]], [[127], [127]]] >>> c_int8 = tf.convert_to_tensor(c, dtype=tf.int8) >>> c_int16 = tf.image.convert_image_dtype(c_int8, dtype=tf.int16) >>> print(c_int16) tf.Tensor( [[[ 256] [ 512]] [[32512] [32512]]], shape=(2, 2, 1), dtype=int16) >>> c_int8_back = tf.image.convert_image_dtype(c_int16, dtype=tf.int8) >>> print(c_int8_back) tf.Tensor( [[[ 1] [ 2]] [[127] [127]]], shape=(2, 2, 1), dtype=int8) Scaling down from an integer type to another integer type can be a lossy conversion. Notice in the example below that converting `int16` to `uint8` and back to `int16` has lost precision. >>> d = [[[1000], [2000]], [[3000], [4000]]] >>> d_int16 = tf.convert_to_tensor(d, dtype=tf.int16) >>> d_uint8 = tf.image.convert_image_dtype(d_int16, dtype=tf.uint8) >>> d_int16_back = tf.image.convert_image_dtype(d_uint8, dtype=tf.int16) >>> print(d_int16_back) tf.Tensor( [[[ 896] [1920]] [[2944] [3968]]], shape=(2, 2, 1), dtype=int16) Note that converting from floating point inputs to integer types may lead to over/underflow problems. Set saturate to `True` to avoid such problem in problematic conversions. If enabled, saturation will clip the output into the allowed range before performing a potentially dangerous cast (and only before performing such a cast, i.e., when casting from a floating point to an integer type, and when casting from a signed to an unsigned type; `saturate` has no effect on casts between floats, or on casts that increase the type's range). Args: image: An image. dtype: A `DType` to convert `image` to. saturate: If `True`, clip the input before casting (if necessary). name: A name for this operation (optional). Returns: `image`, converted to `dtype`. Raises: AttributeError: Raises an attribute error when dtype is neither float nor integer. rCrz.dtype must be either floating point or integerz4image dtype must be either floating point or integer convert_imagerqNrr)rrras_dtype is_floating is_integerAttributeErrorrr identityrr/rfloordiv saturate_castrmultiply) rCrrrscale_in scale_outrscaledrs r2rrK soD   G 4% //% %   5#3#3 I JJ  )?)? O PP ekk   e$ // ~~dOeW5+9 {{%"2"2h))i I A9q=1""5%0 ''DA+9+9vu48+9+9& ''u5$ue,$QHqL1  u481+9+92  U%6%6]]5%d 3;+9+9>   }}UE*U[[__$  u48G+9+9L C""5%0 ''DAS+9+9Vvu48W+9+9+9s3BK!K!4AK!9K!AK!8>K!K!!K*zimage.rgb_to_grayscalecZtj|d|g5}tj|d}|j}t |t j }gd}tj||ddg}tj|d}t |||cdddS#1swYyxYw)aKConverts one or more images from RGB to Grayscale. Outputs a tensor of the same `DType` and rank as `images`. The size of the last dimension of the output is 1, containing the Grayscale value of the pixels. >>> original = tf.constant([[[1.0, 2.0, 3.0]]]) >>> converted = tf.image.rgb_to_grayscale(original) >>> print(converted.numpy()) [[[1.81...]]] Args: images: The RGB tensor to convert. The last dimension must have size 3 and should contain RGB values. name: A name for the operation (optional). Returns: The converted grayscale image(s). rgb_to_grayscalerr)gŏ1w-!?bX9?v/?rpN) rrrrrrrbr tensordotr r)rrrr rgb_weights gray_floats r2rr s, ~~d.9 BT  " "6 9FJ#FFNN;I+K##I{RHEJ&&z26J z:D A B B Bs A>B!!B*zimage.grayscale_to_rgbc:tj|d|g5}t|}tj|d}t j t j |dz d}t j|tjgt j ddgz}t j|d}t j|||}|j|jdd jdg|cdddS#1swYyxYw) ayConverts one or more images from Grayscale to RGB. Outputs a tensor of the same `DType` and rank as `images`. The size of the last dimension of the output is 3, containing the RGB value of the pixels. The input images' last dimension must be size 1. >>> original = tf.constant([[[1.0], [2.0], [3.0]]]) >>> converted = tf.image.grayscale_to_rgb(original) >>> print(converted.numpy()) [[[1. 1. 1.] [2. 2. 2.] [3. 3. 3.]]] Args: images: The Grayscale tensor to convert. The last dimension must be size 1. name: A name for the operation (optional). Returns: The converted grayscale image(s). grayscale_to_rgbrrrqrrrKNrp)rrrmrr rrDonesrrconcattilerur< concatenate)rrrank_1 shape_list multiplesrgbs r2rr( s. ~~d.9 T "6 *F  " "6 9F  " "9>> A#=q AF>>& =>((A./0J  Q/I .. 6CMM&""$Sb)55qc:;    s C.DDzimage.random_huec|dkDr td|dkr tdtjg| ||}t||S)aOAdjust the hue of RGB images by a random factor. Equivalent to `adjust_hue()` but uses a `delta` randomly picked in the interval `[-max_delta, max_delta)`. `max_delta` must be in the interval `[0, 0.5]`. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.random_hue(x, 0.2) For producing deterministic results given a `seed` value, use `tf.image.stateless_random_hue`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: RGB image or images. The size of the last dimension must be 3. max_delta: float. The maximum value for the random delta. seed: An operation-specific seed. It will be used in conjunction with the graph-level seed to determine the real seeds that will be used in this operation. Please see the documentation of set_random_seed for its interaction with the graph-level random seed. Returns: Adjusted image(s), same shape and DType as `image`. Raises: ValueError: if `max_delta` is invalid. rmax_delta must be <= 0.5.rrry)rSrr adjust_huers r2 random_huerM sPN_ 0 11] 6 77  # #B ID I% E5 !!r4zimage.stateless_random_huec|dkDr td|dkr tdtjg| ||}t||S)aAdjust the hue of RGB images by a random factor deterministically. Equivalent to `adjust_hue()` but uses a `delta` randomly picked in the interval `[-max_delta, max_delta)`. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). `max_delta` must be in the interval `[0, 0.5]`. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> seed = (1, 2) >>> tf.image.stateless_random_hue(x, 0.2, seed) Args: image: RGB image or images. The size of the last dimension must be 3. max_delta: float. The maximum value for the random delta. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. Returns: Adjusted image(s), same shape and DType as `image`. Raises: ValueError: if `max_delta` is invalid. rrrrr)rSrrrrs r2stateless_random_huer~ sTP_ 0 11] 6 77  7 7  z)$ @% E5 !!r4zimage.adjust_huectj|d|g5}tjr|dks|dkDr t dtj |d}|j }|tjtjfvr|}nt|tj}tj||}t||cdddS#1swYyxYw)aXAdjust hue of RGB images. This is a convenience method that converts an RGB image to float representation, converts it to HSV, adds an offset to the hue channel, converts back to RGB and then back to the original data type. If several adjustments are chained it is advisable to minimize the number of redundant conversions. `image` is an RGB image. The image hue is adjusted by converting the image(s) to HSV and rotating the hue channel (H) by `delta`. The image is then converted back to RGB. `delta` must be in the interval `[-1, 1]`. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.adjust_hue(x, 0.2) Args: image: RGB image or images. The size of the last dimension must be 3. delta: float. How much to add to the hue channel. name: A name for this operation (optional). Returns: Adjusted image(s), same shape and DType as `image`. Raises: InvalidArgumentError: image must have at least 3 dimensions. InvalidArgumentError: The size of the last dimension must be 3. ValueError: if `delta` is not in the interval of `[-1, 1]`. Usage Example: >>> image = [[[1, 2, 3], [4, 5, 6]], ... [[7, 8, 9], [10, 11, 12]], ... [[13, 14, 15], [16, 17, 18]]] >>> image = tf.constant(image) >>> tf.image.adjust_hue(image, 0.2) rrprqz%delta must be in the interval [-1, 1]rCrN) rrrexecuting_eagerlyrSrrrrrbrrr)rCrrrr rgb_altereds r2rr st ~~dL5'28d  " uqy@AA  ! !%g 6EJfnnfnn55i%eV^^>> x = tf.constant([[[1, 2, 3], ... [4, 5, 6]], ... [[7, 8, 9], ... [10, 11, 12]]], dtype=tf.uint8) >>> tf.image.random_jpeg_quality(x, 75, 95) For producing deterministic results given a `seed` value, use `tf.image.stateless_random_jpeg_quality`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: 3D image. Size of the last dimension must be 1 or 3. min_jpeg_quality: Minimum jpeg encoding quality to use. max_jpeg_quality: Maximum jpeg encoding quality to use. seed: An operation-specific seed. It will be used in conjunction with the graph-level seed to determine the real seeds that will be used in this operation. Please see the documentation of set_random_seed for its interaction with the graph-level random seed. Returns: Adjusted image(s), same shape and DType as `image`. Raises: ValueError: if `min_jpeg_quality` or `max_jpeg_quality` is invalid. rd.jpeg encoding range must be between 0 and 100.8`min_jpeg_quality` must be less than `max_jpeg_quality`.)rzr)rSrrrradjust_jpeg_qualityrCmin_jpeg_qualitymax_jpeg_qualityrz jpeg_qualitys r2random_jpeg_qualityr swN.26F6L E FF)) O PP**2+;+;0417 ?, UL 11r4z#image.stateless_random_jpeg_qualityc|dks|dks |dkDs|dkDr td||k\r tdtjg|||tj}t ||S)a5Deterministically radomize jpeg encoding quality for inducing jpeg noise. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). `min_jpeg_quality` must be in the interval `[0, 100]` and less than `max_jpeg_quality`. `max_jpeg_quality` must be in the interval `[0, 100]`. Usage Example: >>> x = tf.constant([[[1, 2, 3], ... [4, 5, 6]], ... [[7, 8, 9], ... [10, 11, 12]]], dtype=tf.uint8) >>> seed = (1, 2) >>> tf.image.stateless_random_jpeg_quality(x, 75, 95, seed) Args: image: 3D image. Size of the last dimension must be 1 or 3. min_jpeg_quality: Minimum jpeg encoding quality to use. max_jpeg_quality: Maximum jpeg encoding quality to use. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) Returns: Adjusted image(s), same shape and DType as `image`. Raises: ValueError: if `min_jpeg_quality` or `max_jpeg_quality` is invalid. rr r r )rArrrzr)rSrrrrrrs r2stateless_random_jpeg_qualityr3 swV.26F6L E FF)) O PP%>> '0@t LL, UL 11r4zimage.adjust_jpeg_qualityctj|d|g5tj|d}|jj d}|j }t |tjd}t|s%tj|tj}tj||}tj|||}t ||dcd d d S#1swYy xYw) aAdjust jpeg encoding quality of an image. This is a convenience method that converts an image to uint8 representation, encodes it to jpeg with `jpeg_quality`, decodes it, and then converts back to the original data type. `jpeg_quality` must be in the interval `[0, 100]`. Usage Examples: >>> x = [[[0.01, 0.02, 0.03], ... [0.04, 0.05, 0.06]], ... [[0.07, 0.08, 0.09], ... [0.10, 0.11, 0.12]]] >>> x_jpeg = tf.image.adjust_jpeg_quality(x, 75) >>> x_jpeg.numpy() array([[[0.00392157, 0.01960784, 0.03137255], [0.02745098, 0.04313726, 0.05490196]], [[0.05882353, 0.07450981, 0.08627451], [0.08235294, 0.09803922, 0.10980393]]], dtype=float32) Note that floating point values are expected to have values in the range [0,1) and values outside this range are clipped. >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.adjust_jpeg_quality(x, 75) Note that `jpeg_quality` 100 is still lossy compression. >>> x = tf.constant([[[1, 2, 3], ... [4, 5, 6]], ... [[7, 8, 9], ... [10, 11, 12]]], dtype=tf.uint8) >>> tf.image.adjust_jpeg_quality(x, 100) Args: image: 3D image. The size of the last dimension must be None, 1 or 3. jpeg_quality: Python int or Tensor of type int32. jpeg encoding quality. dct_method: An optional string. Specifies the DCT method to use for JPEG decompression. Currently available options are ["INTEGER_FAST", "INTEGER_ACCURATE"]. Defaults to "" which maps to "INTEGER_FAST", sacrificing image quality for speed. name: A name for this operation (optional). Returns: Adjusted image, same shape and DType as `image`. Raises: InvalidArgumentError: quality must be in [0,100] InvalidArgumentError: image must have 1 or 3 channels rrCrrpTrr)channels dct_methodN)rrrrAr>rrruint8r.rrencode_jpeg_variable_quality decode_jpeg)rCrrrrrs r2rrk sF ~~d1E7;A  ! !%g 6E{{""$R(HJ v||d CE l #**>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.random_saturation(x, 5, 10) For producing deterministic results given a `seed` value, use `tf.image.stateless_random_saturation`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image: RGB image or images. The size of the last dimension must be 3. lower: float. Lower bound for the random saturation factor. upper: float. Upper bound for the random saturation factor. seed: An operation-specific seed. It will be used in conjunction with the graph-level seed to determine the real seeds that will be used in this operation. Please see the documentation of set_random_seed for its interaction with the graph-level random seed. Returns: Adjusted image(s), same shape and DType as `image`. Raises: ValueError: if `upper <= lower` or if `lower < 0`. rrrry)rSrradjust_saturationrCrrrzsaturation_factors r2random_saturationr  sPT e^ - .. QY 2 33 //E5tL 5"3 44r4z!image.stateless_random_saturationc||kr td|dkr tdtjg|||}t||S)aWAdjust the saturation of RGB images by a random factor deterministically. Equivalent to `adjust_saturation()` but uses a `saturation_factor` randomly picked in the interval `[lower, upper)`. Guarantees the same results given the same `seed` independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> seed = (1, 2) >>> tf.image.stateless_random_saturation(x, 0.5, 1.0, seed) Args: image: RGB image or images. The size of the last dimension must be 3. lower: float. Lower bound for the random saturation factor. upper: float. Upper bound for the random saturation factor. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) Returns: Adjusted image(s), same shape and DType as `image`. Raises: ValueError: if `upper <= lower` or if `lower < 0`. rrrr)rSrrrrs r2stateless_random_saturationr" sSN e^ - .. QY 2 33*CC uU7 5"3 44r4zimage.adjust_saturationcftj|d|g5}tj|d}|j}|tj tj fvr|}nt|tj }tj||}t||cdddS#1swYyxYw)a@Adjust saturation of RGB images. This is a convenience method that converts RGB images to float representation, converts them to HSV, adds an offset to the saturation channel, converts back to RGB and then back to the original data type. If several adjustments are chained it is advisable to minimize the number of redundant conversions. `image` is an RGB image or images. The image saturation is adjusted by converting the images to HSV and multiplying the saturation (S) channel by `saturation_factor` and clipping. The images are then converted back to RGB. `saturation_factor` must be in the interval `[0, inf)`. Usage Example: >>> x = [[[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0]], ... [[7.0, 8.0, 9.0], ... [10.0, 11.0, 12.0]]] >>> tf.image.adjust_saturation(x, 0.5) Args: image: RGB image or images. The size of the last dimension must be 3. saturation_factor: float. Factor to multiply the saturation by. name: A name for this operation (optional). Returns: Adjusted image(s), same shape and DType as `image`. Raises: InvalidArgumentError: input must have 3 channels rrCrN) rrrrrrrbrrr)rCrrrrrs r2rr% sR ~~d/%9 5T  ! !%g 6EJfnnfnn55i%eV^^   xA .F >>&/ =>>> /AActj|d5tj|dd}t j |d|cdddS#1swYyxYw)a8Convenience function to check if the 'contents' encodes a PNG image. Args: contents: 0-D `string`. The encoded image bytes. name: A name for the operation (optional) Returns: A scalar boolean tensor indicating if 'contents' may be a PNG image. is_png is susceptible to false positives. is_pngrrKsPNrNr&r(s r2_is_pngr-p sK ~~dH%8   xA .F >>&)$ 7888r*zio.decode_and_crop_jpegzimage.decode_and_crop_jpegz io.decode_bmpzimage.decode_bmpz io.decode_gifzimage.decode_gifzio.decode_jpegzimage.decode_jpegz io.decode_pngzimage.decode_pngzio.encode_jpegzimage.encode_jpegzio.extract_jpeg_shapezimage.extract_jpeg_shapez io.encode_pngzimage.encode_pngcVtjtj|||S)aPNG-encode an image. `image` is a rank-N Tensor of type uint8 or uint16 with shape `batch_dims + [height, width, channels]`, where `channels` is: * 1: for grayscale. * 2: for grayscale + alpha. * 3: for RGB. * 4: for RGBA. The ZLIB compression level, `compression`, can be -1 for the PNG-encoder default or a value from 0 to 9. 9 is the highest compression level, generating the smallest output, but is slower. Args: image: A `Tensor`. Must be one of the following types: `uint8`, `uint16`. Rank N >= 3 with shape `batch_dims + [height, width, channels]`. compression: An optional `int`. Defaults to `-1`. Compression level. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. )r encode_pngrr)rC compressionrs r2r/r/ s)4  ! ! E"K 77r4zio.decode_imagezimage.decode_imagec vtj|d5|dn|}|tjtjtj fvr>|}tj }t tj|||||cdddStj||||cdddS#1swYyxYw)aFunction for `decode_bmp`, `decode_gif`, `decode_jpeg`, and `decode_png`. Detects whether an image is a BMP, GIF, JPEG, or PNG, and performs the appropriate operation to convert the input bytes `string` into a `Tensor` of type `dtype`. Note: `decode_gif` returns a 4-D array `[num_frames, height, width, 3]`, as opposed to `decode_bmp`, `decode_jpeg` and `decode_png`, which return 3-D arrays `[height, width, num_channels]`. Make sure to take this into account when constructing your graph if you are intermixing GIF files with BMP, JPEG, and/or PNG files. Alternately, set the `expand_animations` argument of this function to `False`, in which case the op will return 3-dimensional tensors and will truncate animated GIF files to the first frame. NOTE: If the first frame of an animated GIF does not occupy the entire canvas (maximum frame width x maximum frame height), then it fills the unoccupied areas (in the first frame) with zeros (black). For frames after the first frame that does not occupy the entire canvas, it uses the previous frame to fill the unoccupied areas. Args: contents: A `Tensor` of type `string`. 0-D. The encoded image bytes. channels: An optional `int`. Defaults to `0`. Number of color channels for the decoded image. dtype: The desired DType of the returned `Tensor`. name: A name for the operation (optional) expand_animations: An optional `bool`. Defaults to `True`. Controls the shape of the returned op's output. If `True`, the returned op will produce a 3-D tensor for PNG, JPEG, and BMP files; and a 4-D tensor for all GIFs, whether animated or not. If, `False`, the returned op will produce a 3-D tensor for all file types and will truncate animated GIFs to the first frame. Returns: `Tensor` with type `dtype` and a 3- or 4-dimensional shape, depending on the file type and the value of the `expand_animations` parameter. Raises: ValueError: On incorrect number of channels. decode_imageNr)r)rexpand_animationsr) rrrrbruint16rrr2)r)rrrr3 dest_dtypes r2r2r2 sd ~~dN+$q(H V^^V\\6==AAjmme  $ $ 1  ' (  ' '- sA,B/ B//B8zimage.total_variationcvtj|d5|jj}|dk(r=|ddddddf|ddddddfz }|ddddddf|ddddddfz }d}n[|dk(rK|ddddddddf|ddddddddfz }|ddddddddf|ddddddddfz }gd}n t dt j t j|| t j t j|| z}ddd|S#1swYSxYw) aqCalculate and return the total variation for one or more images. The total variation is the sum of the absolute differences for neighboring pixel-values in the input images. This measures how much noise is in the images. This can be used as a loss-function during optimization so as to suppress noise in images. If you have a batch of images, then you should calculate the scalar loss-value as the sum: `loss = tf.reduce_sum(tf.image.total_variation(images))` This implements the anisotropic 2-D version of the formula described here: https://en.wikipedia.org/wiki/Total_variation_denoising Args: images: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`. name: A name for the operation (optional). Raises: ValueError: if images.shape is not a 3-D or 4-D vector. Returns: The total variation of `images`. If `images` was 4-D, return a 1-D float Tensor of shape `[batch]` with the total variation for each image in the batch. If `images` was 3-D, return a scalar float with the total variation for that image. total_variationrKrqNrpr)rqrorKz+'images' must be either 3 or 4-dimensional.r)rrr<rhrSr reduce_sumabs)rrrh pixel_dif1 pixel_dif2sum_axistot_vars r2r7r7 sWF ~~d-. F     $ $E z !"a(#fSbS!QY&77j!QR(#fQQY&77jh ! !QRA+&3B31 )==j!QA+&1crc1 )==jh F GG HLL48DHLL48D E = FD .E FD .s D D..D8z#image.sample_distorted_bounding_boxc |rtj|\} } n(tjrt d|dd\} } t j |d5tj||| | |||||| cdddS#1swYyxYw)aRGenerate a single randomly distorted bounding box for an image. Bounding box annotations are often supplied in addition to ground-truth labels in image recognition or object localization tasks. A common technique for training such a system is to randomly distort an image while preserving its content, i.e. *data augmentation*. This Op outputs a randomly distorted localization of an object, i.e. bounding box, given an `image_size`, `bounding_boxes` and a series of constraints. The output of this Op is a single bounding box that may be used to crop the original image. The output is returned as 3 tensors: `begin`, `size` and `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize what the bounding box looks like. Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and the height of the underlying image. For example, ```python # Generate a single distorted bounding box. begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box( tf.shape(image), bounding_boxes=bounding_boxes, min_object_covered=0.1) # Draw the bounding box in an image summary. image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0), bbox_for_draw) tf.compat.v1.summary.image('images_with_box', image_with_box) # Employ the bounding box to distort the image. distorted_image = tf.slice(image, begin, size) ``` Note that if no bounding box information is available, setting `use_image_if_no_bounding_boxes = true` will assume there is a single implicit bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is false and no bounding boxes are supplied, an error is raised. For producing deterministic results given a `seed` value, use `tf.image.stateless_sample_distorted_bounding_box`. Unlike using the `seed` param with `tf.image.random_*` ops, `tf.image.stateless_random_*` ops guarantee the same results given the same seed independent of how many times the function is called, and independent of global seed settings (e.g. tf.random.set_seed). Args: image_size: A `Tensor`. Must be one of the following types: `uint8`, `int8`, `int16`, `int32`, `int64`. 1-D, containing `[height, width, channels]`. bounding_boxes: A `Tensor` of type `float32`. 3-D with shape `[batch, N, 4]` describing the N bounding boxes associated with the image. seed: An optional `int`. Defaults to `0`. If `seed` is set to non-zero, the random number generator is seeded by the given `seed`. Otherwise, it is seeded by a random seed. min_object_covered: A Tensor of type `float32`. Defaults to `0.1`. The cropped area of the image must contain at least this fraction of any bounding box supplied. The value of this parameter should be non-negative. In the case of 0, the cropped area does not need to overlap any of the bounding boxes supplied. aspect_ratio_range: An optional list of `floats`. Defaults to `[0.75, 1.33]`. The cropped area of the image must have an aspect `ratio = width / height` within this range. area_range: An optional list of `floats`. Defaults to `[0.05, 1]`. The cropped area of the image must contain a fraction of the supplied image within this range. max_attempts: An optional `int`. Defaults to `100`. Number of attempts at generating a cropped region of the image of the specified constraints. After `max_attempts` failures, return the entire image. use_image_if_no_bounding_boxes: An optional `bool`. Defaults to `False`. Controls behavior if no bounding boxes supplied. If true, assume an implicit bounding box covering the whole input. If false, raise an error. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (begin, size, bboxes). begin: A `Tensor`. Has the same type as `image_size`. 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to `tf.slice`. size: A `Tensor`. Has the same type as `image_size`. 1-D, containing `[target_height, target_width, -1]`. Provide as input to `tf.slice`. bboxes: A `Tensor` of type `float32`. 3-D with shape `[1, 1, 4]` containing the distorted bounding box. Provide as input to `tf.image.draw_bounding_boxes`. Raises: ValueError: If no seed is specified and op determinism is enabled. zztf.image.sample_distorted_bounding_box requires a non-zero seed to be passed in when determinism is enabled, but got seed=z;. Please pass in a non-zero seed, e.g. by passing "seed=1".)rrsample_distorted_bounding_boxrzseed2min_object_coveredaspect_ratio_range area_range max_attemptsuse_image_if_no_bounding_boxesrN) r get_seedris_op_determinism_enabledrSrrr sample_distorted_bounding_box_v2) image_sizebounding_boxesrzrBrCrDrErFrseed1rAs r2rIrIR sN ''-LE5 '')  DDH6JF G HHLE5 ~~d;<   9 9 --!'E     s BB z-image.stateless_sample_distorted_bounding_boxc tj|d5tj||||||||| cdddS#1swYyxYw)a Generate a randomly distorted bounding box for an image deterministically. Bounding box annotations are often supplied in addition to ground-truth labels in image recognition or object localization tasks. A common technique for training such a system is to randomly distort an image while preserving its content, i.e. *data augmentation*. This Op, given the same `seed`, deterministically outputs a randomly distorted localization of an object, i.e. bounding box, given an `image_size`, `bounding_boxes` and a series of constraints. The output of this Op is a single bounding box that may be used to crop the original image. The output is returned as 3 tensors: `begin`, `size` and `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize what the bounding box looks like. Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and the height of the underlying image. The output of this Op is guaranteed to be the same given the same `seed` and is independent of how many times the function is called, and independent of global seed settings (e.g. `tf.random.set_seed`). Example usage: >>> image = np.array([[[1], [2], [3]], [[4], [5], [6]], [[7], [8], [9]]]) >>> bbox = tf.constant( ... [0.0, 0.0, 1.0, 1.0], dtype=tf.float32, shape=[1, 1, 4]) >>> seed = (1, 2) >>> # Generate a single distorted bounding box. >>> bbox_begin, bbox_size, bbox_draw = ( ... tf.image.stateless_sample_distorted_bounding_box( ... tf.shape(image), bounding_boxes=bbox, seed=seed)) >>> # Employ the bounding box to distort the image. >>> tf.slice(image, bbox_begin, bbox_size) >>> # Draw the bounding box in an image summary. >>> colors = np.array([[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]) >>> tf.image.draw_bounding_boxes( ... tf.expand_dims(tf.cast(image, tf.float32),0), bbox_draw, colors) Note that if no bounding box information is available, setting `use_image_if_no_bounding_boxes = true` will assume there is a single implicit bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is false and no bounding boxes are supplied, an error is raised. Args: image_size: A `Tensor`. Must be one of the following types: `uint8`, `int8`, `int16`, `int32`, `int64`. 1-D, containing `[height, width, channels]`. bounding_boxes: A `Tensor` of type `float32`. 3-D with shape `[batch, N, 4]` describing the N bounding boxes associated with the image. seed: A shape [2] Tensor, the seed to the random number generator. Must have dtype `int32` or `int64`. (When using XLA, only `int32` is allowed.) min_object_covered: A Tensor of type `float32`. Defaults to `0.1`. The cropped area of the image must contain at least this fraction of any bounding box supplied. The value of this parameter should be non-negative. In the case of 0, the cropped area does not need to overlap any of the bounding boxes supplied. aspect_ratio_range: An optional list of `floats`. Defaults to `[0.75, 1.33]`. The cropped area of the image must have an aspect `ratio = width / height` within this range. area_range: An optional list of `floats`. Defaults to `[0.05, 1]`. The cropped area of the image must contain a fraction of the supplied image within this range. max_attempts: An optional `int`. Defaults to `100`. Number of attempts at generating a cropped region of the image of the specified constraints. After `max_attempts` failures, return the entire image. use_image_if_no_bounding_boxes: An optional `bool`. Defaults to `False`. Controls behavior if no bounding boxes supplied. If true, assume an implicit bounding box covering the whole input. If false, raise an error. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (begin, size, bboxes). begin: A `Tensor`. Has the same type as `image_size`. 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to `tf.slice`. size: A `Tensor`. Has the same type as `image_size`. 1-D, containing `[target_height, target_width, -1]`. Provide as input to `tf.slice`. bboxes: A `Tensor` of type `float32`. 3-D with shape `[1, 1, 4]` containing the distorted bounding box. Provide as input to `tf.image.draw_bounding_boxes`. 'stateless_sample_distorted_bounding_box rJrKrzrBrCrDrErFrN)rrrrNrOs r2rNrN sR^ ~~dEF   @ @% --!'E     s ?AzG`seed2` arg is deprecated.Use sample_distorted_bounding_box_v2 instead.)date instructionsc |s'|s%tjrtd|d|tj| d5t j ||||||||||  cdddS#1swYyxYw)a:Generate a single randomly distorted bounding box for an image. Bounding box annotations are often supplied in addition to ground-truth labels in image recognition or object localization tasks. A common technique for training such a system is to randomly distort an image while preserving its content, i.e. *data augmentation*. This Op outputs a randomly distorted localization of an object, i.e. bounding box, given an `image_size`, `bounding_boxes` and a series of constraints. The output of this Op is a single bounding box that may be used to crop the original image. The output is returned as 3 tensors: `begin`, `size` and `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize what the bounding box looks like. Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and height of the underlying image. For example, ```python # Generate a single distorted bounding box. begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box( tf.shape(image), bounding_boxes=bounding_boxes, min_object_covered=0.1) # Draw the bounding box in an image summary. image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0), bbox_for_draw) tf.compat.v1.summary.image('images_with_box', image_with_box) # Employ the bounding box to distort the image. distorted_image = tf.slice(image, begin, size) ``` Note that if no bounding box information is available, setting `use_image_if_no_bounding_boxes = True` will assume there is a single implicit bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is false and no bounding boxes are supplied, an error is raised. Args: image_size: A `Tensor`. Must be one of the following types: `uint8`, `int8`, `int16`, `int32`, `int64`. 1-D, containing `[height, width, channels]`. bounding_boxes: A `Tensor` of type `float32`. 3-D with shape `[batch, N, 4]` describing the N bounding boxes associated with the image. seed: An optional `int`. Defaults to `0`. If either `seed` or `seed2` are set to non-zero, the random number generator is seeded by the given `seed`. Otherwise, it is seeded by a random seed. seed2: An optional `int`. Defaults to `0`. A second seed to avoid seed collision. min_object_covered: A Tensor of type `float32`. Defaults to `0.1`. The cropped area of the image must contain at least this fraction of any bounding box supplied. The value of this parameter should be non-negative. In the case of 0, the cropped area does not need to overlap any of the bounding boxes supplied. aspect_ratio_range: An optional list of `floats`. Defaults to `[0.75, 1.33]`. The cropped area of the image must have an aspect ratio = width / height within this range. area_range: An optional list of `floats`. Defaults to `[0.05, 1]`. The cropped area of the image must contain a fraction of the supplied image within this range. max_attempts: An optional `int`. Defaults to `100`. Number of attempts at generating a cropped region of the image of the specified constraints. After `max_attempts` failures, return the entire image. use_image_if_no_bounding_boxes: An optional `bool`. Defaults to `False`. Controls behavior if no bounding boxes supplied. If true, assume an implicit bounding box covering the whole input. If false, raise an error. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (begin, size, bboxes). begin: A `Tensor`. Has the same type as `image_size`. 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to `tf.slice`. size: A `Tensor`. Has the same type as `image_size`. 1-D, containing `[target_height, target_width, -1]`. Provide as input to `tf.slice`. bboxes: A `Tensor` of type `float32`. 3-D with shape `[1, 1, 4]` containing the distorted bounding box. Provide as input to `tf.image.draw_bounding_boxes`. Raises: ValueError: If no seed is specified and op determinism is enabled. ztf.compat.v1.image.sample_distorted_bounding_box requires "seed" or "seed2" to be non-zero when determinism is enabled. Please pass in a non-zero seed, e.g. by passing "seed=1". Got seed=z and seed2=r?r@N)rrHrSrrrrI) rJrKrzrArBrCrDrErFrs r2r?r?LsP e @ @ B  ??CfE    ~~d;<   9 9 --!'E     s A))A2zimage.non_max_suppressionr-infctj|d5tj|d}tj|d}tj|||||cdddS#1swYyxYw)aGreedily selects a subset of bounding boxes in descending order of score. Prunes away boxes that have high intersection-over-union (IOU) overlap with previously selected boxes. Bounding boxes are supplied as `[y1, x1, y2, x2]`, where `(y1, x1)` and `(y2, x2)` are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval `[0, 1]`) or absolute. Note that this algorithm is agnostic to where the origin is in the coordinate system. Note that this algorithm is invariant to orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system result in the same boxes being selected by the algorithm. The output of this operation is a set of integers indexing into the input collection of bounding boxes representing the selected boxes. The bounding box coordinates corresponding to the selected indices can then be obtained using the `tf.gather` operation. For example: ```python selected_indices = tf.image.non_max_suppression( boxes, scores, max_output_size, iou_threshold) selected_boxes = tf.gather(boxes, selected_indices) ``` Args: boxes: A 2-D float `Tensor` of shape `[num_boxes, 4]`. scores: A 1-D float `Tensor` of shape `[num_boxes]` representing a single score corresponding to each box (each row of boxes). max_output_size: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non-max suppression. iou_threshold: A 0-D float tensor representing the threshold for deciding whether boxes overlap too much with respect to IOU. score_threshold: A 0-D float tensor representing the threshold for deciding when to remove boxes based on score. name: A name for the operation (optional). Returns: selected_indices: A 1-D integer `Tensor` of shape `[M]` representing the selected indices from the boxes tensor, where `M <= max_output_size`. non_max_suppression iou_thresholdrscore_thresholdN)rrrrnon_max_suppression_v3)boxesscoresmax_output_sizerVrWrs r2rUrUsoZ ~~d12P))-oNM++/1O  / /v0= P PPPs AA((A1z%image.non_max_suppression_with_scoresrc ,tj|d5tj|d}tj|d}tj|d}tj||||||d\}}} ||fcdddS#1swYyxYw) a Greedily selects a subset of bounding boxes in descending order of score. Prunes away boxes that have high intersection-over-union (IOU) overlap with previously selected boxes. Bounding boxes are supplied as `[y1, x1, y2, x2]`, where `(y1, x1)` and `(y2, x2)` are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval `[0, 1]`) or absolute. Note that this algorithm is agnostic to where the origin is in the coordinate system. Note that this algorithm is invariant to orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system result in the same boxes being selected by the algorithm. The output of this operation is a set of integers indexing into the input collection of bounding boxes representing the selected boxes. The bounding box coordinates corresponding to the selected indices can then be obtained using the `tf.gather` operation. For example: ```python selected_indices, selected_scores = tf.image.non_max_suppression_padded( boxes, scores, max_output_size, iou_threshold=1.0, score_threshold=0.1, soft_nms_sigma=0.5) selected_boxes = tf.gather(boxes, selected_indices) ``` This function generalizes the `tf.image.non_max_suppression` op by also supporting a Soft-NMS (with Gaussian weighting) mode (c.f. Bodla et al, https://arxiv.org/abs/1704.04503) where boxes reduce the score of other overlapping boxes instead of directly causing them to be pruned. Consequently, in contrast to `tf.image.non_max_suppression`, `tf.image.non_max_suppression_with_scores` returns the new scores of each input box in the second output, `selected_scores`. To enable this Soft-NMS mode, set the `soft_nms_sigma` parameter to be larger than 0. When `soft_nms_sigma` equals 0, the behavior of `tf.image.non_max_suppression_with_scores` is identical to that of `tf.image.non_max_suppression` (except for the extra output) both in function and in running time. Note that when `soft_nms_sigma` > 0, Soft-NMS is performed and `iou_threshold` is ignored. `iou_threshold` is only used for standard NMS. Args: boxes: A 2-D float `Tensor` of shape `[num_boxes, 4]`. scores: A 1-D float `Tensor` of shape `[num_boxes]` representing a single score corresponding to each box (each row of boxes). max_output_size: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non-max suppression. iou_threshold: A 0-D float tensor representing the threshold for deciding whether boxes overlap too much with respect to IOU. score_threshold: A 0-D float tensor representing the threshold for deciding when to remove boxes based on score. soft_nms_sigma: A 0-D float tensor representing the sigma parameter for Soft NMS; see Bodla et al (c.f. https://arxiv.org/abs/1704.04503). When `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard) NMS. name: A name for the operation (optional). Returns: selected_indices: A 1-D integer `Tensor` of shape `[M]` representing the selected indices from the boxes tensor, where `M <= max_output_size`. selected_scores: A 1-D float tensor of shape `[M]` representing the corresponding scores for each selected box, where `M <= max_output_size`. Scores only differ from corresponding input scores when using Soft NMS (i.e. when `soft_nms_sigma>0`) non_max_suppression_with_scoresrVrrWsoft_nms_sigmaF)pad_to_max_output_sizeN)rrrrnon_max_suppression_v5) rYrZr[rVrWr^rselected_indicesselected_scoresr:s r2r]r]sP ~~d=>-))-oNM++/1O**-/N  . .       % ' _ ,---s A)B  Bz"image.non_max_suppression_overlapsctj|d5tj|d}tj|||||cdddS#1swYyxYw)a7Greedily selects a subset of bounding boxes in descending order of score. Prunes away boxes that have high overlap with previously selected boxes. N-by-n overlap values are supplied as square matrix. The output of this operation is a set of integers indexing into the input collection of bounding boxes representing the selected boxes. The bounding box coordinates corresponding to the selected indices can then be obtained using the `tf.gather` operation. For example: ```python selected_indices = tf.image.non_max_suppression_overlaps( overlaps, scores, max_output_size, iou_threshold) selected_boxes = tf.gather(boxes, selected_indices) ``` Args: overlaps: A 2-D float `Tensor` of shape `[num_boxes, num_boxes]` representing the n-by-n box overlap values. scores: A 1-D float `Tensor` of shape `[num_boxes]` representing a single score corresponding to each box (each row of boxes). max_output_size: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non-max suppression. overlap_threshold: A 0-D float tensor representing the threshold for deciding whether boxes overlap too much with respect to the provided overlap values. score_threshold: A 0-D float tensor representing the threshold for deciding when to remove boxes based on score. name: A name for the operation (optional). Returns: selected_indices: A 1-D integer `Tensor` of shape `[M]` representing the selected indices from the overlaps tensor, where `M <= max_output_size`. non_max_suppression_overlapsoverlap_thresholdrN)rrrr!non_max_suppression_with_overlaps)overlapsrZr[rerWrs r2rfrfWsaP ~~d:;O-- 35  : :&/+>> x = tf.constant([[[1.0, 2.0, 3.0]]]) >>> tf.image.rgb_to_yiq(x) Args: images: 2-D or higher rank. Image data to convert. Last dimension must be size 3. Returns: images: tensor with the same shape as `images`. rrkernelrrqraxes)rr_rgb_to_yiq_kernelrr<rhrrrrjrhs r2 rgb_to_yiqrosg.  h 7&   8 =&     " "%   FF519+s1C DDr4)rqrqrq)g 7p?ghPV0D?zimage.yiq_to_rgbctj|d}tjt|jd}|j j }t j|||dz gdggS)aConverts one or more images from YIQ to RGB. Outputs a tensor of the same shape as the `images` tensor, containing the RGB value of the pixels. The output is only well defined if the Y value in images are in [0,1], I value are in [-0.5957,0.5957] and Q value are in [-0.5226,0.5226]. Args: images: 2-D or higher rank. Image data to convert. Last dimension must be size 3. Returns: images: tensor with the same shape as `images`. rrrjrrqrrk)rr_yiq_to_rgb_kernelrr<rhrrrns r2 yiq_to_rgbrrsg"  h 7&   8 =&     " "%   FF519+s1C DDr4)rhgxÅ¿g>?)rgx|ҿgb!z)rg}?gEzimage.rgb_to_yuvctj|d}tjt|jd}|j j }t j|||dz gdggS)a=Converts one or more images from RGB to YUV. Outputs a tensor of the same shape as the `images` tensor, containing the YUV value of the pixels. The output is only well defined if the value in images are in [0, 1]. There are two ways of representing an image: [0, 255] pixel values range or [0, 1] (as float) pixel values range. Users need to convert the input image into a float [0, 1] range. Args: images: 2-D or higher rank. Image data to convert. Last dimension must be size 3. Returns: images: tensor with the same shape as `images`. rrrjrrqrrk)rr_rgb_to_yuv_kernelrr<rhrrrns r2 rgb_to_yuvrusg&  h 7&   8 =&     " "%   FF519+s1C DDr4)rg;jAٿgA@)g>  . .q 1& >>  . .q 1&+''rs 4 \\&,,":Sb!"HV[["-=$>@+ dai419(?(?(E &*+ ++$$dD\2.&& &--   !7 ;ff=M --    hnnVBC[&+F G 6   r4z image.psnrc Ntj|d||g5tj||j}t |t j}t |t j}t |t j}tjtj||gd}tjdtj|ztjdz tjdtjdz tj|zd}t||\}}}tj|5tj |cdddcdddS#1swYnxYw dddy#1swYyxYw) asReturns the Peak Signal-to-Noise Ratio between a and b. This is intended to be used on signals (or images). Produces a PSNR value for each image in batch. The last three dimensions of input are expected to be [height, width, depth]. Example: ```python # Read images from file. im1 = tf.decode_png('path/to/im1.png') im2 = tf.decode_png('path/to/im2.png') # Compute PSNR over tf.uint8 Tensors. psnr1 = tf.image.psnr(im1, im2, max_val=255) # Compute PSNR over tf.float32 Tensors. im1 = tf.image.convert_image_dtype(im1, tf.float32) im2 = tf.image.convert_image_dtype(im2, tf.float32) psnr2 = tf.image.psnr(im1, im2, max_val=1.0) # psnr1 and psnr2 both have type tf.float32 and are almost equal. ``` Args: a: First set of images. b: Second set of images. max_val: The dynamic range of the images (i.e., the difference between the maximum the and minimum allowed values). name: Namespace to embed the computation in. Returns: The scalar PSNR between a and b. The returned tensor has type `tf.float32` and shape [batch_size, 1]. PSNR)rerrpg$@rzpsnrrN)rrrrrrrrbrsquared_differencesubtractlognprcontrol_dependenciesr r)abmax_valrmsepsnr_valr:rs r2rrHsDJ ~~dFQF+*mmGQWW-G!'6>>:GAv~~.AAv~~.A   x::1a@, OC   X\\' ""X\\$%77 2r ?#hll3&77 H 31a8LAq& ! !& )*    )**********s$EFF2 FF FF${Gz?Q?cp||zdz}||zdz}||} ||} | | zdz} tj| tj| z} | |z| |zz } |||zdz}|tj|tj|z}||z}|| z |z|| z |zz }| |fS)aHelper function for computing SSIM. SSIM estimates covariances with weighted sums. The default parameters use a biased estimate of the covariance: Suppose `reducer` is a weighted sum, then the mean estimators are \mu_x = \sum_i w_i x_i, \mu_y = \sum_i w_i y_i, where w_i's are the weighted-sum weights, and covariance estimator is cov_{xy} = \sum_i w_i (x_i - \mu_x) (y_i - \mu_y) with assumption \sum_i w_i = 1. This covariance estimator is biased, since E[cov_{xy}] = (1 - \sum_i w_i ^ 2) Cov(X, Y). For SSIM measure with unbiased covariance estimators, pass as `compensation` argument (1 - \sum_i w_i ^ 2). Args: x: First set of images. y: Second set of images. reducer: Function that computes 'local' averages from the set of images. For non-convolutional version, this is usually tf.reduce_mean(x, [1, 2]), and for convolutional version, this is usually tf.nn.avg_pool2d or tf.nn.conv2d with weighted-sum kernel. max_val: The dynamic range (i.e., the difference between the maximum possible allowed value and the minimum allowed value). compensation: Compensation factor. See above. k1: Default value 0.01 k2: Default value 0.03 (SSIM is less sensitivity to K2 for lower values, so it would be better if we took the values in the range of 0 < K2 < 0.4). Returns: A pair containing the luminance measure, and the contrast-structure measure. ro@)rsquare)r:r1reducerr compensationk1k2c1c2mean0mean1num0den0 luminancenum1den1css r2 _ssim_helperrsB W q" W q" !*% !*%  $  (//%"8 8$byTBY') Q# $ #hooa&88 9$ " t bTD[2-." Br4ctj|tj}tj|}t j t j ||j}|t j |dz |jdz z}t j|}|dt j|z z}tj|ddgtj|ddgz}tj|ddg}tj|}tj|||ddgS)z:Function to mimic the 'fspecial' gaussian MATLAB function.rqrgrprA) rrrrrrrangerrr rrsoftmax)r^sigmacoordsgs r2_fspecial_gaussrs  tV\\ 2$   &% ==-u{{ ;&HMM$(EKK 03 66&oof!thooe$$$!!R)I,=,=aAw,OO!!R)! nnQ!   1T4A$6 77r4 ?c tj|tj}tj||j}t j ||g\}} tjtjtj|dd|||gdtjtjtj| dd|| |gdg} tj| 5t j|}dddt||t j dd|ddgd } fd } t#||| || ||\} }|r | |z}||fStjdd gtj}tj$| |z|}tj$||}||fS#1swYxYw) ayComputes SSIM index between img1 and img2 per color channel. This function matches the standard SSIM implementation from: Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing. Details: - 11x11 Gaussian filter of width 1.5 is used. - k1 = 0.01, k2 = 0.03 as in the original paper. Args: img1: First image batch. img2: Second image batch. max_val: The dynamic range of the images (i.e., the difference between the maximum the and minimum allowed values). filter_size: Default value 11 (size of gaussian filter). filter_sigma: Default value 1.5 (width of gaussian filter). k1: Default value 0.01 k2: Default value 0.03 (SSIM is less sensitivity to K2 for lower values, so it would be better if we took the values in the range of 0 < K2 < 0.4). return_index_map: If True returns local SSIM map instead of the global mean. Returns: A pair of tensors containing and channel-wise SSIM and contrast-structure values. The shape is [..., channels]. rrerpr{Nrq)rrc Ptj|}tj|tjdg|ddgd}t j |gdd}tj|tj|ddtj|ddgdS) NrprerrrqrqrqrqVALID)stridespaddingrq)r rArrrdepthwise_conv2d)r:rAr1rjs r2rz"_ssim_per_channel..reducer s OOA E!9#3#3bT5:4F#JKA   6< :A    9  U3BZ);AB)?@! D FFr4r)rconstantrrrr rrr/rrrrrrrrrr)rrr filter_size filter_sigmarrreturn_index_maprrrrrrrssim_valrlrjs @r2_ssim_per_channelrsF$$[ E+%%l$**E,$$dD\2.&&    $$VBr]K@ B ;       $$VBr]K@ B ;   & '$   d #D$ ; 5& >>&Q6":q,A B&, FtT7G\2!#-)R2~H 2   R =D##IND9H   b$ 'B 2A$$s ?GGz image.ssimc tjdd||g5tj|d}tj|d}t||\}}} tj| 5t j |}dddtj||j}t|tj}t|tj}t|tj}t||||||||\} }tj| dgcdddS#1swYxYw#1swYyxYw)a> Computes SSIM index between img1 and img2. This function is based on the standard SSIM implementation from: Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing. Note: The true SSIM is only defined on grayscale. This function does not perform any colorspace transform. (If the input is already YUV, then it will compute YUV SSIM average.) Details: - 11x11 Gaussian filter of width 1.5 is used. - k1 = 0.01, k2 = 0.03 as in the original paper. The image sizes must be at least 11x11 because of the filter size. Example: ```python # Read images (of size 255 x 255) from file. im1 = tf.image.decode_image(tf.io.read_file('path/to/im1.png')) im2 = tf.image.decode_image(tf.io.read_file('path/to/im2.png')) tf.shape(im1) # `img1.png` has 3 channels; shape is `(255, 255, 3)` tf.shape(im2) # `img2.png` has 3 channels; shape is `(255, 255, 3)` # Add an outer batch for each image. im1 = tf.expand_dims(im1, axis=0) im2 = tf.expand_dims(im2, axis=0) # Compute SSIM over tf.uint8 Tensors. ssim1 = tf.image.ssim(im1, im2, max_val=255, filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03) # Compute SSIM over tf.float32 Tensors. im1 = tf.image.convert_image_dtype(im1, tf.float32) im2 = tf.image.convert_image_dtype(im2, tf.float32) ssim2 = tf.image.ssim(im1, im2, max_val=1.0, filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03) # ssim1 and ssim2 both have type tf.float32 and are almost equal. ``` Args: img1: First image batch. 4-D Tensor of shape `[batch, height, width, channels]` with only Positive Pixel Values. img2: Second image batch. 4-D Tensor of shape `[batch, height, width, channels]` with only Positive Pixel Values. max_val: The dynamic range of the images (i.e., the difference between the maximum the and minimum allowed values). filter_size: Default value 11 (size of gaussian filter). filter_sigma: Default value 1.5 (width of gaussian filter). k1: Default value 0.01 k2: Default value 0.03 (SSIM is less sensitivity to K2 for lower values, so it would be better if we took the values in the range of 0 < K2 < 0.4). return_index_map: If True returns local SSIM map instead of the global mean. Returns: A tensor containing an SSIM value for each image in batch or a tensor containing an SSIM value for each pixel for each image in batch if return_index_map is True. Returned SSIM values are in range (-1, 1], when pixel values are non-negative. Returns a tensor with shape: broadcast(img1.shape[:-3], img2.shape[:-3]) or broadcast(img1.shape[:-1], img2.shape[:-1]). NSSIMrrrrp)rrrrrr rrrrrrrbrr) rrrrrrrrr:rssim_per_channels r2ssimr"sP ~~dFT4L18  F 3D  F 3D24>LAq& ! !& )&    %d& mmGTZZ0G!'6>>:G tV^^ 4D tV^^ 4D+D$,8"b,<>a    02$ 7'88 && 88s%AD;.D/B!D;/D8 4D;;E)gǺ?g48EG?ga4?g??g9EGr?zimage.ssim_multiscalec tjdd||g5tj|d}tj|d}t||\}} } tj| 5t j |}dddtj||j}t|tj}t|tj}t|tj}||g} || g} | D cgc]} | dd }} | D cgc]} | dd }} gd}tj|ddtj }d g}t!t#|D]}tjdd |z| 5|d kDr1t%| |Dcgc]2\}}t j&|t j(d g|gd 4c}}|d |z tj*tj, d }t/j0| fdfd}|Dcgc]}t3j4|||d}}t j6|Dcgc]}|dd }}t%|||Dcgc]2\}}}t j&|t j(||gd 4} }}}t9| |||||d\}}|j;t3j<|ddd|j?tAjB|t3j<gzd }tjDtjF||d g}tjH|d gcdddS#1swY xYwcc} wcc} wcc}}wcc}wcc}wcc}}}w#1swYXxYw#1swYyxYw)aComputes the MS-SSIM between img1 and img2. This function assumes that `img1` and `img2` are image batches, i.e. the last three dimensions are [height, width, channels]. Note: The true SSIM is only defined on grayscale. This function does not perform any colorspace transform. (If the input is already YUV, then it will compute YUV SSIM average.) Original paper: Wang, Zhou, Eero P. Simoncelli, and Alan C. Bovik. "Multiscale structural similarity for image quality assessment." Signals, Systems and Computers, 2004. Args: img1: First image batch with only Positive Pixel Values. img2: Second image batch with only Positive Pixel Values. Must have the same rank as img1. max_val: The dynamic range of the images (i.e., the difference between the maximum the and minimum allowed values). power_factors: Iterable of weights for each of the scales. The number of scales used is the length of the list. Index 0 is the unscaled resolution's weight and each increasing scale corresponds to the image being downsampled by 2. Defaults to (0.0448, 0.2856, 0.3001, 0.2363, 0.1333), which are the values obtained in the original paper. filter_size: Default value 11 (size of gaussian filter). filter_sigma: Default value 1.5 (width of gaussian filter). k1: Default value 0.01 k2: Default value 0.03 (SSIM is less sensitivity to K2 for lower values, so it would be better if we took the values in the range of 0 < K2 < 0.4). Returns: A tensor containing an MS-SSIM value for each image in batch. The values are in range [0, 1]. Returns a tensor with shape: broadcast(img1.shape[:-3], img2.shape[:-3]). NzMS-SSIMrrrre)rqrororqrqrctj|d}tj|ddgddgg}|Dcgc]}tj||dc}Scc}w)Nrprqr SYMMETRICmode)r rr)r remainderrr:s r2do_padzssim_multiscale..do_padsR%%i4g gAA'78gCI JaimmAw[9 JJ JsAzScale%drrpcSrrN)r flat_imgsrsr2rz!ssim_multiscale..sy)(Dr4cSrrN)rsr2rz!ssim_multiscale..s r4r)ksizerr)rrrrrr)%rrrrrr rrrrrrrbrrrrlenrBrr reduce_any not_equalrrravg_poolrrrrelupoprrrpowr)!rrr power_factorsrrrrrrrimgsshapesrGheadstailsdivisordivisor_tensormcsrr:t need_paddingr! downscaledhrr mcs_and_ssimms_ssimrrrs! @@@r2ssim_multiscalersZ ~~dId|4Q/  F 3D  F 3D>:G tV^^ 4D tV^^ 4D $>$ A t 4#$ q5dE* !Q9#3#3bT1Iq#AB ) Ah/)!,,X-?-? 1-MN,<< D 13& oo7GWF * #,"3"3J"?@Q1QR5@%@!UE:  !Q9#3#3QFA#>? $ 1 #%  " 6;;r?#G#$#$$$PGGI"(( v{{+,--B8L"" \=1B49G   " .cQ/Q/ && % $  A -#$#$GQ/Q/sAO 1NBO  NO  N 'A%O  N<"7N% AN<1 N+ N<* N0 6N< 7N5:N<:B O N O %N<<O O  Ozimage.image_gradientsc|jjdk7r(tdj|jt j |}t j|\}}}}|ddddddddf|ddddddddfz }|ddddddddf|ddddddddfz }t j|d||g}t j|t j||jgd}t j||}t j||d|g}t j|t j||jgd}t j||}||fS)aReturns image gradients (dy, dx) for each color channel. Both output tensors have the same shape as the input: [batch_size, h, w, d]. The gradient values are organized so that [I(x+1, y) - I(x, y)] is in location (x, y). That means that dy will always have zeros in the last row, and dx will always have zeros in the last column. Usage Example: ```python BATCH_SIZE = 1 IMAGE_HEIGHT = 5 IMAGE_WIDTH = 5 CHANNELS = 1 image = tf.reshape(tf.range(IMAGE_HEIGHT * IMAGE_WIDTH * CHANNELS, delta=1, dtype=tf.float32), shape=(BATCH_SIZE, IMAGE_HEIGHT, IMAGE_WIDTH, CHANNELS)) dy, dx = tf.image.image_gradients(image) print(image[0, :,:,0]) tf.Tensor( [[ 0. 1. 2. 3. 4.] [ 5. 6. 7. 8. 9.] [10. 11. 12. 13. 14.] [15. 16. 17. 18. 19.] [20. 21. 22. 23. 24.]], shape=(5, 5), dtype=float32) print(dy[0, :,:,0]) tf.Tensor( [[5. 5. 5. 5. 5.] [5. 5. 5. 5. 5.] [5. 5. 5. 5. 5.] [5. 5. 5. 5. 5.] [0. 0. 0. 0. 0.]], shape=(5, 5), dtype=float32) print(dx[0, :,:,0]) tf.Tensor( [[1. 1. 1. 1. 0.] [1. 1. 1. 1. 0.] [1. 1. 1. 1. 0.] [1. 1. 1. 1. 0.] [1. 1. 1. 1. 0.]], shape=(5, 5), dtype=float32) ``` Args: image: Tensor with shape [batch_size, h, w, d]. Returns: Pair of tensors (dy, dx) holding the vertical and horizontal image gradients (1-step finite difference). Raises: ValueError: If `image` is not a 4D tensor. rzBimage_gradients expects a 4D tensor [batch_size, h, w, d], not {}.Nrqrpro) r<rhrSrr rArr@rrrrr) rCrXrrrrdydxrAs r2image_gradientsrsgj __! 66%Y__UEKK@A1E"[)"   VQ > ?%Y__UEKK@A1E"[)" R-r4zimage.sobel_edgesc|j}tj|}gdgdgdggdgdgdgg}t|}t j t j|d}t j|d}tj||j}tj|d d |d d gd }d d gd d gd d gd d gg}tj||d}gd}tj|||d} tj ||ggd } tj"| | } | j%|j'|g| S)aaReturns a tensor holding Sobel edge maps. Example usage: For general usage, `image` would be loaded from a file as below: ```python image_bytes = tf.io.read_file(path_to_image_file) image = tf.image.decode_image(image_bytes) image = tf.cast(image, tf.float32) image = tf.expand_dims(image, 0) ``` But for demo purposes, we are using randomly generated values for `image`: >>> image = tf.random.uniform( ... maxval=255, shape=[1, 28, 28, 3], dtype=tf.float32) >>> sobel = tf.image.sobel_edges(image) >>> sobel_y = np.asarray(sobel[0, :, :, :, 0]) # sobel in y-direction >>> sobel_x = np.asarray(sobel[0, :, :, :, 1]) # sobel in x-direction For displaying the sobel results, PIL's [Image Module]( https://pillow.readthedocs.io/en/stable/reference/Image.html) can be used: ```python # Display edge maps for the first channel (at index 0) Image.fromarray(sobel_y[..., 0] / 4 + 0.5).show() Image.fromarray(sobel_x[..., 0] / 4 + 0.5).show() ``` Args: image: Image tensor with shape [batch_size, h, w, d] and type float32 or float64. The image(s) must be 2x2 or larger. Returns: Tensor holding edge maps for each channel. Returns a tensor with shape [batch_size, h, w, d, 2] where the last two dimensions hold [[dy[0], dx[0]], [dy[1], dx[1]], ..., [dy[d-1], dx[d-1]]] calculated using the Sobel filter. )rprrprrr)rqrorq)rprrq)rrro)rqrorrrrqrp sobel_filtersrrREFLECTrrrr)r<r rArrrr! np_asarrayrrrrrrrrrrrur) rCstatic_image_shaperXkernels num_kernels kernels_tf pad_sizesr!routputrAs r2 sobel_edgesrOsET(&+Iy 1*j 1 3'G + LL0099 E' NN7B ''##G5;;?*~~1aR!,?D*1v1v1v1v.) == :& '  # #FJ I&   K+7 ;%   V5 1&%11;-@A -r4zimage.resize_bicubiczAUse `tf.image.resize(...method=ResizeMethod.BICUBIC...)` instead.c6tj|||||SN)rr^rwrr)rr{rr^rwrrs r2r{r{s&  % %  !+   r4zimage.resize_bilinearzBUse `tf.image.resize(...method=ResizeMethod.BILINEAR...)` instead.c6tj|||||Sr)rryrs r2ryrys&  & &  !+   r4zimage.resize_nearest_neighborzJUse `tf.image.resize(...method=ResizeMethod.NEAREST_NEIGHBOR...)` instead.c6tj|||||Sr)rrzrs r2rzrzs&  . .  !+   r4z>Use `tf.image.resize(...method=ResizeMethod.AREA...)` instead.zimage.resize_areazimage.crop_and_resizec 8tj|||||||S)a Extracts crops from the input image tensor and resizes them. Extracts crops from the input image tensor and resizes them using bilinear sampling or nearest neighbor sampling (possibly with aspect ratio change) to a common output size specified by `crop_size`. This is more general than the `crop_to_bounding_box` op which extracts a fixed size slice from the input image and does not allow resizing or aspect ratio change. The crops occur first and then the resize. Returns a tensor with `crops` from the input `image` at positions defined at the bounding box locations in `boxes`. The cropped boxes are all resized (with bilinear or nearest neighbor interpolation) to a fixed `size = [crop_height, crop_width]`. The result is a 4-D tensor `[num_boxes, crop_height, crop_width, depth]`. The resizing is corner aligned. In particular, if `boxes = [[0, 0, 1, 1]]`, the method will give identical results to using `tf.compat.v1.image.resize_bilinear()` or `tf.compat.v1.image.resize_nearest_neighbor()`(depends on the `method` argument) with `align_corners=True`. Args: image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`. Both `image_height` and `image_width` need to be positive. boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor specifies the coordinates of a box in the `box_ind[i]` image and is specified in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the `[0, 1]` interval of normalized image height is mapped to `[0, image_height - 1]` in image height coordinates. We do allow `y1` > `y2`, in which case the sampled crop is an up-down flipped version of the original image. The width dimension is treated similarly. Normalized coordinates outside the `[0, 1]` range are allowed, in which case we use `extrapolation_value` to extrapolate the input image values. box_indices: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`. The value of `box_ind[i]` specifies the image that the `i`-th box refers to. crop_size: A 1-D tensor of 2 elements, `size = [crop_height, crop_width]`. All cropped image patches are resized to this size. The aspect ratio of the image content is not preserved. Both `crop_height` and `crop_width` need to be positive. method: An optional string specifying the sampling method for resizing. It can be either `"bilinear"` or `"nearest"` and default to `"bilinear"`. Currently two sampling methods are supported: Bilinear and Nearest Neighbor. extrapolation_value: An optional `float`. Defaults to `0.0`. Value used for extrapolation, when applicable. name: A name for the operation (optional). Returns: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`. Usage example: >>> BATCH_SIZE = 1 >>> NUM_BOXES = 5 >>> IMAGE_HEIGHT = 256 >>> IMAGE_WIDTH = 256 >>> CHANNELS = 3 >>> CROP_SIZE = (24, 24) >>> image = tf.random.normal(shape=( ... BATCH_SIZE, IMAGE_HEIGHT, IMAGE_WIDTH, CHANNELS) ) >>> boxes = tf.random.uniform(shape=(NUM_BOXES, 4)) >>> box_indices = tf.random.uniform(shape=(NUM_BOXES,), minval=0, ... maxval=BATCH_SIZE, dtype=tf.int32) >>> output = tf.image.crop_and_resize(image, boxes, box_indices, CROP_SIZE) >>> output.shape TensorShape([5, 24, 24, 3]) Example with linear interpolation: >>> image = np.arange(0, 18, 2).astype('float32').reshape(3, 3) >>> result = tf.image.crop_and_resize( ... image[None, :, :, None], ... np.asarray([[0.5,0.5,1,1]]), [0], [3, 3], method='bilinear') >>> result[0][:, :, 0] Example with nearest interpolation: >>> image = np.arange(0, 18, 2).astype('float32').reshape(3, 3) >>> result = tf.image.crop_and_resize( ... image[None, :, :, None], ... np.asarray([[0.5,0.5,1,1]]), [0], [3, 3], method='nearest') >>> result[0][:, :, 0] )rcrop_and_resize)rCrY box_indices crop_sizerextrapolation_valuers r2crop_and_resize_v2rs*R  & &ue[)'-/BD JJr4z.box_ind is deprecated, use box_indices insteadbox_indc htjd|d|}tj|||||||S)Nrr)rdeprecated_argument_lookuprr)rCrYrrrrrrs r2crop_and_resize_v1rLsB  2 2=+3>> x = [[[[0.0], ... [1.0], ... [2.0]], ... [[3.0], ... [4.0], ... [5.0]], ... [[6.0], ... [7.0], ... [8.0]]]] >>> tf.compat.v1.image.extract_glimpse(x, size=(2, 2), offsets=[[1, 1]], ... centered=False, normalized=False) Args: input: A `Tensor` of type `float32`. A 4-D float tensor of shape `[batch_size, height, width, channels]`. size: A `Tensor` of type `int32`. A 1-D tensor of 2 elements containing the size of the glimpses to extract. The glimpse height must be specified first, following by the glimpse width. offsets: A `Tensor` of type `float32`. A 2-D integer tensor of shape `[batch_size, 2]` containing the y, x locations of the center of each window. centered: An optional `bool`. Defaults to `True`. indicates if the offset coordinates are centered relative to the image, in which case the (0, 0) offset is relative to the center of the input images. If false, the (0,0) offset corresponds to the upper left corner of the input images. normalized: An optional `bool`. Defaults to `True`. indicates if the offset coordinates are normalized. uniform_noise: An optional `bool`. Defaults to `True`. indicates if the noise should be generated using a uniform distribution or a Gaussian distribution. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. inputr^offsetscentered normalized uniform_noiser)rextract_glimpser s r2rrcs-X  & &  !  r4c <tj||||||d|S)a Extracts a glimpse from the input tensor. Returns a set of windows called glimpses extracted at location `offsets` from the input tensor. If the windows only partially overlaps the inputs, the non-overlapping areas will be filled with random noise. The result is a 4-D tensor of shape `[batch_size, glimpse_height, glimpse_width, channels]`. The channels and batch dimensions are the same as that of the input tensor. The height and width of the output windows are specified in the `size` parameter. The argument `normalized` and `centered` controls how the windows are built: * If the coordinates are normalized but not centered, 0.0 and 1.0 correspond to the minimum and maximum of each height and width dimension. * If the coordinates are both normalized and centered, they range from -1.0 to 1.0. The coordinates (-1.0, -1.0) correspond to the upper left corner, the lower right corner is located at (1.0, 1.0) and the center is at (0, 0). * If the coordinates are not normalized they are interpreted as numbers of pixels. Usage Example: >>> x = [[[[0.0], ... [1.0], ... [2.0]], ... [[3.0], ... [4.0], ... [5.0]], ... [[6.0], ... [7.0], ... [8.0]]]] >>> tf.image.extract_glimpse(x, size=(2, 2), offsets=[[1, 1]], ... centered=False, normalized=False) Args: input: A `Tensor` of type `float32`. A 4-D float tensor of shape `[batch_size, height, width, channels]`. size: A `Tensor` of type `int32`. A 1-D tensor of 2 elements containing the size of the glimpses to extract. The glimpse height must be specified first, following by the glimpse width. offsets: A `Tensor` of type `float32`. A 2-D integer tensor of shape `[batch_size, 2]` containing the y, x locations of the center of each window. centered: An optional `bool`. Defaults to `True`. indicates if the offset coordinates are centered relative to the image, in which case the (0, 0) offset is relative to the center of the input images. If false, the (0,0) offset corresponds to the upper left corner of the input images. normalized: An optional `bool`. Defaults to `True`. indicates if the offset coordinates are normalized. noise: An optional `string`. Defaults to `uniform`. indicates if the noise should be `uniform` (uniform distribution), `gaussian` (gaussian distribution), or `zero` (zero padding). name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. F)r r^r r rnoiserr)rextract_glimpse_v2)r r^r r rrrs r2rrs0X  ) )     r4z"image.combined_non_max_suppressionc Ttj|d5tj|tjd}tj|tjd}tj|}t j ||||||||cdddS#1swYyxYw)aH Greedily selects a subset of bounding boxes in descending order of score. This operation performs non_max_suppression on the inputs per batch, across all classes. Prunes away boxes that have high intersection-over-union (IOU) overlap with previously selected boxes. Bounding boxes are supplied as [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval [0, 1]) or absolute. Note that this algorithm is agnostic to where the origin is in the coordinate system. Also note that this algorithm is invariant to orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system result in the same boxes being selected by the algorithm. The output of this operation is the final boxes, scores and classes tensor returned after performing non_max_suppression. Args: boxes: A 4-D float `Tensor` of shape `[batch_size, num_boxes, q, 4]`. If `q` is 1 then same boxes are used for all classes otherwise, if `q` is equal to number of classes, class-specific boxes are used. scores: A 3-D float `Tensor` of shape `[batch_size, num_boxes, num_classes]` representing a single score corresponding to each box (each row of boxes). max_output_size_per_class: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non-max suppression per class max_total_size: A int32 scalar representing maximum number of boxes retained over all classes. Note that setting this value to a large number may result in OOM error depending on the system workload. iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU. score_threshold: A float representing the threshold for deciding when to remove boxes based on score. pad_per_class: If false, the output nmsed boxes, scores and classes are padded/clipped to `max_total_size`. If true, the output nmsed boxes, scores and classes are padded to be of length `max_size_per_class`*`num_classes`, unless it exceeds `max_total_size` in which case it is clipped to `max_total_size`. Defaults to false. clip_boxes: If true, the coordinates of output nmsed boxes will be clipped to [0, 1]. If false, output the box coordinates as it is. Defaults to true. name: A name for the operation (optional). Returns: 'nmsed_boxes': A [batch_size, max_detections, 4] float32 tensor containing the non-max suppressed boxes. 'nmsed_scores': A [batch_size, max_detections] float32 tensor containing the scores for the boxes. 'nmsed_classes': A [batch_size, max_detections] float32 tensor containing the class for boxes. 'valid_detections': A [batch_size] int32 tensor indicating the number of valid detections per batch item. Only the top valid_detections[i] entries in nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the entries are zero paddings. combined_non_max_suppressionrVrrWN)rrrrrbrr) rYrZmax_output_size_per_classmax_total_sizerVrW pad_per_class clip_boxesrs r2rrs@ ~~d:;4))V^^/CM++v~~4EGO**>:N  5 5 v0.-  4!444s A=BB'c tjd5tj|dd\}}}}tj|dd\}}}} t j |tj |gd} t j|tj | gd} t j |tj |gd} t j|tj |gd} t j | | z dt j | | z dz}||z ||z z}||z | |z z}d}|tj |gdz|z |z}||z }|cdddS#1swYyxYw) ayCalculates the overlap (iou - intersection over union) between boxes_a and boxes_b. Args: boxes_a: a tensor with a shape of [batch_size, N, 4]. N is the number of boxes per image. The last dimension is the pixel coordinates in [ymin, xmin, ymax, xmax] form. boxes_b: a tensor with a shape of [batch_size, M, 4]. M is the number of boxes. The last dimension is the pixel coordinates in [ymin, xmin, ymax, xmax] form. Returns: intersection_over_union: a tensor with as a shape of [batch_size, N, M], representing the ratio of intersection area over union area (IoU) between two boxes bbox_overlaprrornum_or_size_splitsr)rrorqrg:0yE>N)rrr splitrr.rr5)boxes_aboxes_ba_y_mina_x_mina_y_maxa_x_maxb_y_minb_x_minb_y_maxb_x_maxi_xmini_xmaxi_ymini_ymaxi_areaa_areab_areaEPSILONu_areaintersection_over_unions r2 _bbox_overlapr3es} ~~n%#)2!!*5&GWgw)2!!*5&GWgw  $$Wi8:F   $$Wi8:F   $$Wi8:F   $$Wi8:F    &1 ( 0 0&6/A FGFGg$5 6FGg$5 6FG i))&)< r?s r2cross_suppression_funcz6_suppression_loop_body..cross_suppression_funcs y- )++r4rc|kSrrN)_boxes _box_slice _thresholdr>rs r2rz(_suppression_loop_body..s )c/r4rpc|SrrN)_iouloop_condition_iou_sumr:s r2rz(_suppression_loop_body..s.r4Tror)rqrprqrqN)rrr rArrrrr3rrrrr logical_andrr;r8rrrrr)rYrV output_sizerr? num_tilesrrFr=r:r6masksuppressed_iousuppressed_boxs `` r2_suppression_loop_bodyrUs$ ~~-.1I&q)Y6I'*J+ 3?A'>!+Y :>)4c :EKK I D NN900A3Y1- /15 68A8I8I J 9a89:=>X9G GE   ej"a%8 9E8&&    A s 3V\\ CEFCIIK_1Id  {C!G 33e1I1Is K>L''L0z image.non_max_suppression_paddedic tj|d5|sQ|jj7|jjdkDrt dj ||d}t |||||||| \} } |s | dd| f} nXtjtj|ddtj|dgd} tj| | } | | fcdddS#1swYyxYw)aL Greedily selects a subset of bounding boxes in descending order of score. Performs algorithmically equivalent operation to tf.image.non_max_suppression, with the addition of an optional parameter which zero-pads the output to be of size `max_output_size`. The output of this operation is a tuple containing the set of integers indexing into the input collection of bounding boxes representing the selected boxes and the number of valid indices in the index set. The bounding box coordinates corresponding to the selected indices can then be obtained using the `tf.slice` and `tf.gather` operations. For example: ```python selected_indices_padded, num_valid = tf.image.non_max_suppression_padded( boxes, scores, max_output_size, iou_threshold, score_threshold, pad_to_max_output_size=True) selected_indices = tf.slice( selected_indices_padded, tf.constant([0]), num_valid) selected_boxes = tf.gather(boxes, selected_indices) ``` Args: boxes: a tensor of rank 2 or higher with a shape of [..., num_boxes, 4]. Dimensions except the last two are batch dimensions. scores: a tensor of rank 1 or higher with a shape of [..., num_boxes]. max_output_size: a scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression. Note that setting this value to a large number may result in OOM error depending on the system workload. iou_threshold: a float representing the threshold for deciding whether boxes overlap too much with respect to IoU (intersection over union). score_threshold: a float representing the threshold for box scores. Boxes with a score that is not larger than this threshold will be suppressed. pad_to_max_output_size: whether to pad the output idx to max_output_size. Must be set to True when the input is a batch of images. name: name of operation. sorted_input: a boolean indicating whether the input boxes and scores are sorted in descending order by the score. canonicalized_coordinates: if box coordinates are given as `[y_min, x_min, y_max, x_max]`, setting to True eliminate redundant computation to canonicalize box coordinates. tile_size: an integer representing the number of boxes in a tile, i.e., the maximum number of boxes per image that can be used to suppress other boxes in parallel; larger tile_size means larger parallelism and potentially more redundant work. Returns: idx: a tensor with a shape of [..., num_boxes] representing the indices selected by non-max suppression. The leading dimensions are the batch dimensions of the input boxes. All numbers are within [0, num_boxes). For each image (i.e., idx[i]), only the first num_valid[i] indices (i.e., idx[i][:num_valid[i]]) are valid. num_valid: a tensor of rank 0 or higher with a shape of [...] representing the number of valid indices in idx. Its dimensions are the batch dimensions of the input boxes. Raises: ValueError: When set pad_to_max_output_size to False for batched input. non_max_suppression_paddedNrozB'pad_to_max_output_size' (value {}) must be True for batched inputrr) rrr<rDrSrnon_max_suppression_padded_v2r rrArr) rYrZr[rVrWr_r sorted_inputcanonicalized_coordinatesr?r num_valid batch_dimss r2rWrWsF ~~d89 !     +0A0F0F0J))/0F)GI I | d2 v //s CC55C>rY)experimental_implementsc N #$%&'d}tj|dd} tj|d} tj|d| dg}tj|d| g}tj|d} |tdk7rt j d5t j||kD|j} || z}tjt j| |jd } || z}ddd|st j d 5tj|dd \&$'%t jt j&d 'd }tj|&'fd &'fd\}}t jt j$d %d }tj|$%fd$%fd\}}tj||||gd }ddd|s|||\}}}n%tj |t"j$}t jt j&t jt j(| t"j*t jt"j*z t"j$z| z }tj,t j|t"j*ddgd|gddgg}tj,t j|t"j*ddgd|gg}| |z}|z##fd}fd}t/j.||||tj0| gt"j$t3j4dgt7j8gdt7j8gt7j8dgt7j8gg\}}}}t j:|}|t jt=j>t jt j@|dkDd gt"j$tjt jB|dddzdt"j$z }t j:|| dz }|st jB| | z}tj|tj|dzdg}tjtjDtj|dg|| dg}tj0| gt"j$} tjt jBd}!tj|d}"tjF|!|"k|| }tj|| }||fS#1swYxYw#1swYxYw)aNon-maximum suppression. Prunes away boxes that have high intersection-over-union (IOU) overlap with previously selected boxes. Bounding boxes are supplied as `[y1, x1, y2, x2]`, where `(y1, x1)` and `(y2, x2)` are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval `[0, 1]`) or absolute. The bounding box coordinates are cannonicalized to `[y_min, x_min, y_max, x_max]`, where `(y_min, x_min)` and `(y_max, x_mas)` are the coordinates of the lower left and upper right corner. User may indiciate the input box coordinates are already canonicalized to eliminate redundant work by setting canonicalized_coordinates to `True`. Note that this algorithm is agnostic to where the origin is in the coordinate system. Note that this algorithm is invariant to orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system result in the same boxes being selected by the algorithm. Similar to tf.image.non_max_suppression, non_max_suppression_padded implements hard NMS but can operate on a batch of images and improves performance by titling the bounding boxes. Non_max_suppression_padded should be preferred over tf.image_non_max_suppression when running on devices with abundant parallelsim for higher computation speed. For soft NMS, refer to tf.image.non_max_suppression_with_scores. While a serial NMS algorithm iteratively uses the highest-scored unprocessed box to suppress boxes, this algorithm uses many boxes to suppress other boxes in parallel. The key idea is to partition boxes into tiles based on their score and suppresses boxes tile by tile, thus achieving parallelism within a tile. The tile size determines the degree of parallelism. In cross suppression (using boxes of tile A to suppress boxes of tile B), all boxes in A can independently suppress boxes in B. Self suppression (suppressing boxes of the same tile) needs to be iteratively applied until there's no more suppression. In each iteration, boxes that cannot be suppressed are used to suppress boxes in the same tile. boxes = boxes.pad_to_multiply_of(tile_size) num_tiles = len(boxes) // tile_size output_boxes = [] for i in range(num_tiles): box_tile = boxes[i*tile_size : (i+1)*tile_size] for j in range(i - 1): # in parallel suppress boxes in box_tile using boxes from suppressing_tile suppressing_tile = boxes[j*tile_size : (j+1)*tile_size] iou = _bbox_overlap(box_tile, suppressing_tile) # if the box is suppressed in iou, clear it to a dot box_tile *= _update_boxes(iou) # Iteratively handle the diagnal tile. iou = _box_overlap(box_tile, box_tile) iou_changed = True while iou_changed: # boxes that are not suppressed by anything else suppressing_boxes = _get_suppressing_boxes(iou) # boxes that are suppressed by suppressing_boxes suppressed_boxes = _get_suppressed_boxes(iou, suppressing_boxes) # clear iou to 0 for boxes that are suppressed, as they cannot be used # to suppress other boxes any more new_iou = _clear_iou(iou, suppressed_boxes) iou_changed = (new_iou != iou) iou = new_iou # remaining boxes that can still suppress others, are selected boxes. output_boxes.append(_get_suppressing_boxes(iou)) if len(output_boxes) >= max_output_size: break Args: boxes: a tensor of rank 2 or higher with a shape of [..., num_boxes, 4]. Dimensions except the last two are batch dimensions. The last dimension represents box coordinates, given as [y_1, x_1, y_2, x_2]. The coordinates on each dimension can be given in any order (see also `canonicalized_coordinates`) but must describe a box with a positive area. scores: a tensor of rank 1 or higher with a shape of [..., num_boxes]. max_output_size: a scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression. iou_threshold: a float representing the threshold for deciding whether boxes overlap too much with respect to IoU (intersection over union). score_threshold: a float representing the threshold for box scores. Boxes with a score that is not larger than this threshold will be suppressed. sorted_input: a boolean indicating whether the input boxes and scores are sorted in descending order by the score. canonicalized_coordinates: if box coordinates are given as `[y_min, x_min, y_max, x_max]`, setting to True eliminate redundant computation to canonicalize box coordinates. tile_size: an integer representing the number of boxes in a tile, i.e., the maximum number of boxes per image that can be used to suppress other boxes in parallel; larger tile_size means larger parallelism and potentially more redundant work. Returns: idx: a tensor with a shape of [..., num_boxes] representing the indices selected by non-max suppression. The leading dimensions are the batch dimensions of the input boxes. All numbers are within [0, num_boxes). For each image (i.e., idx[i]), only the first num_valid[i] indices (i.e., idx[i][:num_valid[i]]) are valid. num_valid: a tensor of rank 0 or higher with a shape of [...] representing the number of valid indices in idx. Its dimensions are the batch dimensions of the input boxes. Raises: ValueError: When set pad_to_max_output_size to False for batched input. ctjd5tj|dd}t j ||dd}t j ||dd}dddfS#1swYxYw)a^Sort boxes based their score from highest to lowest. Args: scores: a tensor with a shape of [batch_size, num_boxes] representing the scores of boxes. boxes: a tensor with a shape of [batch_size, num_boxes, 4] representing the boxes. Returns: sorted_scores: a tensor with a shape of [batch_size, num_boxes] representing the sorted scores. sorted_boxes: a tensor representing the sorted boxes. sorted_scores_indices: a tensor with a shape of [batch_size, num_boxes] representing the index of the scores in a sorted descending order. sort_scores_and_boxesrq DESCENDING)r direction)rr]N)rrrargsortr gather)rZrYsorted_scores_indices sorted_scores sorted_boxess r2_sort_scores_and_boxesz=non_max_suppression_padded_v2.._sort_scores_and_boxess / 0&.. qL2&& 'aAm%% &Q1l  ,(= ==s A A..A7NrrprrrSfilter_by_scorerocanonicalize_coordinatesrrc fSrrNy_1y_2sr2rz/non_max_suppression_padded_v2.. sCjr4c fSrrNrmsr2rz/non_max_suppression_padded_v2.. 3*r4c fSrrNx_1x_2sr2rz/non_max_suppression_padded_v2..rpr4c fSrrNrtsr2rz/non_max_suppression_padded_v2..rrr4rrcbtjtj|k|kSr)rrO reduce_min) unused_boxesunused_thresholdrPrr[num_iterationss r2 _loop_condz1non_max_suppression_padded_v2.._loop_cond6s1   K(?: n r4c"t||||Sr)rU)rYrVrPrr?s r2rDz.suppression_loop_body;s ! }k3  ;;r4)NNr)shape_invariantsrq)$r rArrrrrrrrrr less_equalrrr zeros_likerrceilr.rbrrrrrr TensorShaper5rtop_krrrewhere)(rYrZr[rVrWrZr[r?rir] num_boxesr score_maskbox_mask y_1_is_miny_miny_max x_1_is_minx_minx_maxsorted_indicesrnum_boxes_after_paddingr}rDselected_boxesr:rPr\r index_offsets gather_idx invalid_index idx_indexnum_valid_expandedr|rurvrnros( ` ` @@@@@r2rYrY{sK^>4u%cr**ooe$R()   EB 1#5 6%   Vb)_ 5&u%a(*f % ) *==/!96<<Hj f&& -- EKK 0!5h xe  # 2 3 E$??!!5c3S&&   c'lCL 9;j\\ (*<>leU&&   c'lCL 9;j\\ (*<>leUueU;!De E$ $:65$I!FE>))& EN mm --y/:FNN L -- 6>> 2 34 ll     #,  ,# --mmE6>>*aVaX1v,F H% ==mmFFNN+q!fq#h-? A&%O*i7. ;'1&;&;  //:, 5   q !  " "? 3  " "2 &  " "D6 *  " "2 & '#.![!{O<)(-- ll --++q 1#'(.  6   nn4aB4@# % R C//:"?(. 6-##HNN?$CQG) ,,Y: $66] ,# :6) i} E Es'A"X (CX XX$c tj|d5tj|d}tj|d}tj||||||cdddS#1swYyxYw)aGreedily selects a subset of bounding boxes in descending order of score. Performs algorithmically equivalent operation to tf.image.non_max_suppression, with the addition of an optional parameter which zero-pads the output to be of size `max_output_size`. The output of this operation is a tuple containing the set of integers indexing into the input collection of bounding boxes representing the selected boxes and the number of valid indices in the index set. The bounding box coordinates corresponding to the selected indices can then be obtained using the `tf.slice` and `tf.gather` operations. For example: ```python selected_indices_padded, num_valid = tf.image.non_max_suppression_padded( boxes, scores, max_output_size, iou_threshold, score_threshold, pad_to_max_output_size=True) selected_indices = tf.slice( selected_indices_padded, tf.constant([0]), num_valid) selected_boxes = tf.gather(boxes, selected_indices) ``` Args: boxes: A 2-D float `Tensor` of shape `[num_boxes, 4]`. scores: A 1-D float `Tensor` of shape `[num_boxes]` representing a single score corresponding to each box (each row of boxes). max_output_size: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non-max suppression. iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU. score_threshold: A float representing the threshold for deciding when to remove boxes based on score. pad_to_max_output_size: bool. If True, size of `selected_indices` output is padded to `max_output_size`. name: A name for the operation (optional). Returns: selected_indices: A 1-D integer `Tensor` of shape `[M]` representing the selected indices from the boxes tensor, where `M <= max_output_size`. valid_outputs: A scalar integer `Tensor` denoting how many elements in `selected_indices` are valid. Valid elements occur first, then padding. rWrVrrWN)rrrrnon_max_suppression_v4)rYrZr[rVrWr_rs r2non_max_suppression_padded_v1rksr\ ~~d89H))-oNM++/1O  / /v0=0F H HHHs AA))A2zimage.draw_bounding_boxescd|tj|||Stj||||S)a'Draw bounding boxes on a batch of images. Outputs a copy of `images` but draws on top of the pixels zero or more bounding boxes specified by the locations in `boxes`. The coordinates of the each bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and the height of the underlying image. For example, if an image is 100 x 200 pixels (height x width) and the bounding box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of the bounding box will be `(40, 10)` to `(180, 50)` (in (x,y) coordinates). Parts of the bounding box may fall outside the image. Args: images: A `Tensor`. Must be one of the following types: `float32`, `half`. 4-D with shape `[batch, height, width, depth]`. A batch of images. boxes: A `Tensor` of type `float32`. 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding boxes. colors: A `Tensor` of type `float32`. 2-D. A list of RGBA colors to cycle through for the boxes. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `images`. Usage Example: >>> # create an empty image >>> img = tf.zeros([1, 3, 3, 3]) >>> # draw a box around the image >>> box = np.array([0, 0, 1, 1]) >>> boxes = box.reshape([1, 1, 4]) >>> # alternate between red and blue >>> colors = np.array([[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]) >>> tf.image.draw_bounding_boxes(img, boxes, colors) )rdraw_bounding_boxesdraw_bounding_boxes_v2)rrYcolorsrs r2rrs6d ^  , ,VUD AA  - -feVT JJr4ct||||S)a'Draw bounding boxes on a batch of images. Outputs a copy of `images` but draws on top of the pixels zero or more bounding boxes specified by the locations in `boxes`. The coordinates of the each bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and the height of the underlying image. For example, if an image is 100 x 200 pixels (height x width) and the bounding box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of the bounding box will be `(40, 10)` to `(180, 50)` (in (x,y) coordinates). Parts of the bounding box may fall outside the image. Args: images: A `Tensor`. Must be one of the following types: `float32`, `half`. 4-D with shape `[batch, height, width, depth]`. A batch of images. boxes: A `Tensor` of type `float32`. 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding boxes. name: A name for the operation (optional). colors: A `Tensor` of type `float32`. 2-D. A list of RGBA colors to cycle through for the boxes. Returns: A `Tensor`. Has the same type as `images`. Usage Example: >>> # create an empty image >>> img = tf.zeros([1, 3, 3, 3]) >>> # draw a box around the image >>> box = np.array([0, 0, 1, 1]) >>> boxes = box.reshape([1, 1, 4]) >>> # alternate between red and blue >>> colors = np.array([[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]) >>> tf.image.draw_bounding_boxes(img, boxes, colors) )r)rrYrrs r2rrsd vt <tj||||||||| S)a1Generate bounding box proposals from encoded bounding boxes. Args: scores: A 4-D float `Tensor` of shape `[num_images, height, width, num_achors]` containing scores of the boxes for given anchors, can be unsorted. bbox_deltas: A 4-D float `Tensor` of shape `[num_images, height, width, 4 x num_anchors]` encoding boxes with respect to each anchor. Coordinates are given in the form `[dy, dx, dh, dw]`. image_info: A 2-D float `Tensor` of shape `[num_images, 5]` containing image information Height, Width, Scale. anchors: A 2-D float `Tensor` of shape `[num_anchors, 4]` describing the anchor boxes. Boxes are formatted in the form `[y1, x1, y2, x2]`. nms_threshold: A scalar float `Tensor` for non-maximal-suppression threshold. Defaults to 0.7. pre_nms_topn: A scalar int `Tensor` for the number of top scoring boxes to be used as input. Defaults to 6000. min_size: A scalar float `Tensor`. Any box that has a smaller size than min_size will be discarded. Defaults to 16. post_nms_topn: An integer. Maximum number of rois in the output. name: A name for this operation (optional). Returns: rois: Region of interest boxes sorted by their scores. roi_probabilities: scores of the ROI boxes in the ROIs' `Tensor`. rZ bbox_deltas image_infoanchors nms_threshold pre_nms_topnmin_size post_nms_topnr)rgenerate_bounding_box_proposalsrs r2rrs3N  6 6 !!   r4)Tr)rqN)rqrq)FN)rXN)rpN)r皙?NNNNN)rNNNNN)NNrNNNNN)rrr)rrrrrF)rrrrF)FNF)rPrN)NNrPrNN)TTTN)TTuniformN)NN)gffffff?ipi,N)rIr}numpyrtensorflow.python.eagerrrtensorflow.python.frameworkrrrrr r r7r r tensorflow.python.opsr rrrrrrrrrrrrrrrrrrtensorflow.python.utilrr r! tensorflow.python.util.tf_exportr"NotDifferentiabler3r.rIrYr^rar`rmrlrwadd_dispatch_supportr{rrrrrrrrrrrrrr r%r+rErOrsrJrrrrrrregister_unary_elementwise_apirrrrrrrrrrrrrrrrr r"rr%r-decode_and_crop_jpeg decode_bmp decode_gifr decode_png encode_jpegextract_jpeg_shaper/rr2r7rIrN deprecatedr?rrUr]rfrmrorqrrrtrurwrxrrrrrr_MSSSIM_WEIGHTSrrrr{ryrzresize_area_deprecationr|rdeprecated_argsrrrrrr3r;rBrUrWfunctionrYrrrrrNr4r2rs|#+0.3.+3<43+1+1532/*)(,.*6,+,.+/6l#j!)*2345&')*+,56450 @, F9,@,(V@.(V& &' *D(*DZ )* +G++G\ 3; A<A: 0R8 >9>:3Nl "# ,$,B   )!)B'MT = =N=N@>@ "35L!MN ANOANH   N!Nb &' >(>H[| '( f)fR #')NOQ VQVr #$%  &  B' " "( "K\ $n56 (00 %(- Q 7Q h >b! )11+0$ n!"n!bHV ,-. %3$;$;+0 &3/&3R "r* %1$9$9', $3+$3N ,- 6.6r $% (( &))&&)R .26 (( )))7))X "# )1$)1X ,4 *15*1Z $% (( /D)&/Dd "# 6D$6Dr   (( <H)!<H~ &' (( s9)(s9l #$ B%BD #$ %F  ,","^ 'B/ ."0."b  F8F8T &' 12(12h 0R8 32932l &' OA(OAd $% /5&/5d .26 -57-5` $% 25&25j <lO-LM>N>& 8 By !#?@B &%%m&H&HI K .Y+,. &%%m&>&>? A .Y+,. &%%m&>&>? A 0i-.0 &%%m&?&?@ B .Y+,. &%%m&>&>? A 0i-.0 &%%m&?&?@ B >Y!;<> &%%m&F&FG I ?./ 7078 /02 ||#' = 2 =@ "# C$CL 0R8 +,8;8<0426DH*.y9yx :rB @C?C7;9=KO15wCwt 456  45 (,(,5859-1/3AE'+s 57 sl &' '*(-f ! 0P(0Pf 23 3649&M36)- U-4U-p /0 9<6;Fm+/ +O1+O^2768   EE8 !G:<  EE,7768   EE0 !>24  ,E,E^* Z < 2*2*j7t8&""$#&',Up <   Y8Y8z; "# #2 "!$|/$|/~ "# E$EP  @ @F %&'  K"'&+  (  &'(  L#(',  )  ./0   +0!%/4 1 1+00 HK2i/01%%%m&?&?@  "r*  )+- hJ+hJV &'( TM&(    B() B+::BB &'(   Q)Qh "r*    R+Rj /0  0316v/4,0&*P41P4f+#\#LJ8D4N -. .1/4V}6;$(,19>),X/Xz;= 1427-/4'+ 4Hn &2. 2K/2Kj *+, 0=-0=f 23  3615-/25)-.4.r4