&VfddlmZddlmZddlmZddlmZddlmZddlm Z ddl m Z Gdd e Z ed  d/d Z Gd de Zed d0dZGdde Zed d1dZGdde Zed d2dZ d2d ZGd!d"e Zed# d3d$ZGd%d&e Zed' d4d(Zd)ZGd*d+e Zed, d4d-Zd.ZdS)5)backend)ops) keras_export) KerasTensor)any_symbolic_tensors) Operation)compute_conv_output_shapec.eZdZ dfd ZdZdZxZS)RGBToGrayscale channels_lastcVt||_dSN)super__init__ data_format)selfr __class__s P/var/www/html/software/conda/lib/python3.11/site-packages/keras/src/ops/image.pyrzRGBToGrayscale.__init__ s) &cNtj||jS)Nr)rimagergb_to_grayscalerrrs rcallzRGBToGrayscale.calls*}-- (.   rcTt|jdvrtd|jt|jdkrW|jdkr&t |jdddz|jSt d|jddz|jSt|jd krs|jdkr5t |jd f|jddzdz|jSt |jd df|jd dz|jSdS) NwInvalid image rank: expected rank 3 (single image) or rank 4 (batch of images). Received input with shape: image.shape=rr dtyper#rr)lenshape ValueErrorrrr%rs rcompute_output_specz"RGBToGrayscale.compute_output_specsX u{  6 ) )-${--  u{  q ?22"5;ss#3d#:%+NNNN"4%+abb/#9MMMM    " "?22"[^% AbD(99D@+ # Ak!""o &  + # "rr __name__ __module__ __qualname__rrr* __classcell__rs@rr r s`$''''''   rr z keras.ops.image.rgb_to_grayscaler ct|fr#t||Stj||S)aBConvert RGB images to grayscale. This function converts RGB images to grayscale images. It supports both 3D and 4D tensors, where the last dimension represents channels. Args: image: Input RGB image or batch of RGB images. Must be a 3D tensor with shape `(height, width, channels)` or a 4D tensor with shape `(batch, height, width, channels)`. data_format: A string specifying the data format of the input tensor. It can be either `"channels_last"` or `"channels_first"`. `"channels_last"` corresponds to inputs with shape `(batch, height, width, channels)`, while `"channels_first"` corresponds to inputs with shape `(batch, channels, height, width)`. Defaults to `"channels_last"`. Returns: Grayscale image or batch of grayscale images. Examples: >>> import numpy as np >>> from keras.src import ops >>> x = np.random.random((2, 4, 4, 3)) >>> y = ops.image.rgb_to_grayscale(x) >>> y.shape (2, 4, 4, 1) >>> x = np.random.random((4, 4, 3)) # Single RGB image >>> y = ops.image.rgb_to_grayscale(x) >>> y.shape (4, 4, 1) >>> x = np.random.random((2, 3, 4, 4)) >>> y = ops.image.rgb_to_grayscale(x, data_format="channels_first") >>> y.shape (2, 1, 4, 4) r)rr symbolic_callrrr)rrs rrr6seVUH%%#   -    = ) )  *  rc:eZdZ d fd ZdZdZxZS) ResizebilinearFconstantr c tt||_||_||_||_||_||_||_ ||_ dSr) rrtuplesize interpolation antialiasrcrop_to_aspect_ratiopad_to_aspect_ratio fill_mode fill_value) rr;r<r=r>r?r@rArrs rrzResize.__init__lsa $KK *"&$8!#6 "$rc tj||j|j|j|j|j|j|j |j  S)Nr<r=rr>r?r@rA) rrresizer;r<r=rr>r?r@rArs rrz Resize.callsP}##  I,n(!%!: $ 8n$   rct|jdkr*t|j|jdfz|jSt|jdkrz|jdkr9t|jdf|jz|jdfz|jSt|jd|jdf|jz|jSt d|j) Nrr!r$rr rr#zwInvalid input rank: expected rank 3 (single image) or rank 4 (batch of images). Received input with shape: image.shape=)r'r(rr;r%rr)rs rr*zResize.compute_output_specs u{  q  U[_..ek    " "?22"[^% 1U[_4FF+ #[^U[^4ty@+ ) ; ) )   rr6FFFr7r8r r,r1s@rr5r5ksr!"!#%%%%%%*           rr5zkeras.ops.image.resizer6Fr7r8c t|dkrtd|t|jdkst|jdkrtd|jd|r|rtdt|fr*t |||||||||St j||||||||| S) a. Resize images to size using the specified interpolation method. Args: image: Input image or batch of images. Must be 3D or 4D. size: Size of output image in `(height, width)` format. interpolation: Interpolation method. Available methods are `"nearest"`, `"bilinear"`, and `"bicubic"`. Defaults to `"bilinear"`. antialias: Whether to use an antialiasing filter when downsampling an image. Defaults to `False`. crop_to_aspect_ratio: If `True`, resize the images without aspect ratio distortion. When the original aspect ratio differs from the target aspect ratio, the output image will be cropped so as to return the largest possible window in the image (of size `(height, width)`) that matches the target aspect ratio. By default (`crop_to_aspect_ratio=False`), aspect ratio may not be preserved. pad_to_aspect_ratio: If `True`, pad the images without aspect ratio distortion. When the original aspect ratio differs from the target aspect ratio, the output image will be evenly padded on the short side. fill_mode: When using `pad_to_aspect_ratio=True`, padded areas are filled according to the given mode. Only `"constant"` is supported at this time (fill with constant value, equal to `fill_value`). fill_value: Float. Padding value to use when `pad_to_aspect_ratio=True`. data_format: string, either `"channels_last"` or `"channels_first"`. The ordering of the dimensions in the inputs. `"channels_last"` corresponds to inputs with shape `(batch, height, width, channels)` while `"channels_first"` corresponds to inputs with shape `(batch, channels, height, weight)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be `"channels_last"`. Returns: Resized image or batch of images. Examples: >>> x = np.random.random((2, 4, 4, 3)) # batch of 2 RGB images >>> y = keras.ops.image.resize(x, (2, 2)) >>> y.shape (2, 2, 2, 3) >>> x = np.random.random((4, 4, 3)) # single RGB image >>> y = keras.ops.image.resize(x, (2, 2)) >>> y.shape (2, 2, 3) >>> x = np.random.random((2, 3, 4, 4)) # batch of 2 RGB images >>> y = keras.ops.image.resize(x, (2, 2), ... data_format="channels_first") >>> y.shape (2, 3, 2, 2) r&zrr?r@rA) r'r)r(rr5r3rrrD) rr;r<r=r>r?r@rArs rrDrDsIF 4yyA~~ %" % %    5;!s5;//!33 F7<{ F F F    3     UH%%  '#!5 3!     -    =    #1/   rc4eZdZ dfd ZdZdZxZS) AffineTransformr6r7rr ct||_||_||_||_dSr)rrr<r@rAr)rr<r@rArrs rrzAffineTransform.__init__s? *"$&rcttj|||j|j|j|jS)Nr<r@rAr)rraffine_transformr<r@rArrr transforms rrzAffineTransform.calls=}--  ,n( .   rct|jdvrtd|jt|jdvrtd|jt|j|jS)Nrr )r#r&zInvalid transform rank: expected rank 1 (single transform) or rank 2 (batch of transforms). Received input with shape: transform.shape=r$)r'r(r)rr%rOs rr*z#AffineTransform.compute_output_spec(s u{  6 ) )-${--  y  v - -5#,?55  5;ek::::rr6r7rr r,r1s@rrJrJsi!# ' ' ' ' ' '    ; ; ; ; ; ; ;rrJz keras.ops.image.affine_transformct||fr't||||||Stj||||||S)aApplies the given transform(s) to the image(s). Args: image: Input image or batch of images. Must be 3D or 4D. transform: Projective transform matrix/matrices. A vector of length 8 or tensor of size N x 8. If one row of transform is `[a0, a1, a2, b0, b1, b2, c0, c1]`, then it maps the output point `(x, y)` to a transformed input point `(x', y') = ((a0 x + a1 y + a2) / k, (b0 x + b1 y + b2) / k)`, where `k = c0 x + c1 y + 1`. The transform is inverted compared to the transform mapping input points to output points. Note that gradients are not backpropagated into transformation parameters. Note that `c0` and `c1` are only effective when using TensorFlow backend and will be considered as `0` when using other backends. interpolation: Interpolation method. Available methods are `"nearest"`, and `"bilinear"`. Defaults to `"bilinear"`. fill_mode: Points outside the boundaries of the input are filled according to the given mode. Available methods are `"constant"`, `"nearest"`, `"wrap"` and `"reflect"`. Defaults to `"constant"`. - `"reflect"`: `(d c b a | a b c d | d c b a)` The input is extended by reflecting about the edge of the last pixel. - `"constant"`: `(k k k k | a b c d | k k k k)` The input is extended by filling all values beyond the edge with the same constant value k specified by `fill_value`. - `"wrap"`: `(a b c d | a b c d | a b c d)` The input is extended by wrapping around to the opposite edge. - `"nearest"`: `(a a a a | a b c d | d d d d)` The input is extended by the nearest pixel. fill_value: Value used for points outside the boundaries of the input if `fill_mode="constant"`. Defaults to `0`. data_format: string, either `"channels_last"` or `"channels_first"`. The ordering of the dimensions in the inputs. `"channels_last"` corresponds to inputs with shape `(batch, height, width, channels)` while `"channels_first"` corresponds to inputs with shape `(batch, channels, height, weight)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be `"channels_last"`. Returns: Applied affine transform image or batch of images. Examples: >>> x = np.random.random((2, 64, 80, 3)) # batch of 2 RGB images >>> transform = np.array( ... [ ... [1.5, 0, -20, 0, 1.5, -16, 0, 0], # zoom ... [1, 0, -20, 0, 1, -16, 0, 0], # translation ... ] ... ) >>> y = keras.ops.image.affine_transform(x, transform) >>> y.shape (2, 64, 80, 3) >>> x = np.random.random((64, 80, 3)) # single RGB image >>> transform = np.array([1.0, 0.5, -20, 0.5, 1.0, -16, 0, 0]) # shear >>> y = keras.ops.image.affine_transform(x, transform) >>> y.shape (64, 80, 3) >>> x = np.random.random((2, 3, 64, 80)) # batch of 2 RGB images >>> transform = np.array( ... [ ... [1.5, 0, -20, 0, 1.5, -16, 0, 0], # zoom ... [1, 0, -20, 0, 1, -16, 0, 0], # translation ... ] ... ) >>> y = keras.ops.image.affine_transform(x, transform, ... data_format="channels_first") >>> y.shape (2, 3, 64, 80) rM)rrJr3rrrN)rrPr<r@rArs rrNrN8shUI.//*'!#    -y ) )  * = ) ) # *  rc4eZdZ dfd ZdZdZxZS) ExtractPatchesNr#validr ctt|tr||f}||_||_||_||_||_dSr) rr isinstanceintr;strides dilation_ratepaddingr)rr;rZr[r\rrs rrzExtractPatches.__init__sa  dC  $>>>rNr#rVr r,r1s@rrUrUsi# ''''''"   ???????rrUzkeras.ops.image.extract_patchesNr#rVct|fr't||||||St||||||S)aExtracts patches from the image(s). Args: image: Input image or batch of images. Must be 3D or 4D. size: Patch size int or tuple (patch_height, patch_widht) strides: strides along height and width. If not specified, or if `None`, it defaults to the same value as `size`. dilation_rate: This is the input stride, specifying how far two consecutive patch samples are in the input. For value other than 1, strides must be 1. NOTE: `strides > 1` is not supported in conjunction with `dilation_rate > 1` padding: The type of padding algorithm to use: `"same"` or `"valid"`. data_format: string, either `"channels_last"` or `"channels_first"`. The ordering of the dimensions in the inputs. `"channels_last"` corresponds to inputs with shape `(batch, height, width, channels)` while `"channels_first"` corresponds to inputs with shape `(batch, channels, height, weight)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be `"channels_last"`. Returns: Extracted patches 3D (if not batched) or 4D (if batched) Examples: >>> image = np.random.random( ... (2, 20, 20, 3) ... ).astype("float32") # batch of 2 RGB images >>> patches = keras.ops.image.extract_patches(image, (5, 5)) >>> patches.shape (2, 4, 4, 75) >>> image = np.random.random((20, 20, 3)).astype("float32") # 1 RGB image >>> patches = keras.ops.image.extract_patches(image, (3, 3), (1, 1)) >>> patches.shape (18, 18, 27) )r;rZr[r\rr)rrUr3r_r^s rextract_patchesrjsr\UH%%'#    -      tWmW+   rct|tr|x}}n6t|dkr|d|d}}ntd||dkr|jd}n|dkr |jd}|s|}||z|z} t j| |j } t j | |||| f} d } t|jd kr#d } t j |d }t j || ||||} | r!t j | d } | S)Nr&rr#zPInvalid `size` argument. Expected an int or a tuple of length 2. Received: size=r r!channels_firstrar$FrTaxis)inputskernelrZr\rr[)rXrYr' TypeErrorr(rnumpyeyer%reshape expand_dimsnnconvsqueeze) rr;rZr[r\rpatch_hpatch_wrdout_dimrp _unbatchedpatchess rr_r_s$   '' Ta7DG A:> A A   o%%k"o ( ( (k"o +-G ]  wek  : :F ] " "';8FJ 5;1  ))%a)88joo# G9-''a'88 Nrc,eZdZdfd ZdZdZxZS)MapCoordinatesr#r7rcrt||_||_||_dSr)rrorderr@rA)rrr@rArs rrzMapCoordinates.__init__=s2  "$rchtj|||j|j|jS)N)rr@rA)rrmap_coordinatesrr@rArr coordinatess rrzMapCoordinates.callCs6},,  *n -   rc6|jdt|jkr%td|jd|jdt|jdkrtd|jt|jdd|jS)Nrz_First dim of `coordinates` must be the same as the rank of `image`. Received image with shape: z and coordinate leading dim of r&zOInvalid coordinates rank: expected at least rank 2. Received input with shape: r#r$)r(r'r)rr%rs rr*z"MapCoordinates.compute_output_specLs  Q 3u{#3#3 3 39.3k99#."3A"699  { ! !A % %C/:/@CC ;,QRR0 DDDDr)r#r7rr,r1s@rrr<sb%%%%%%     E E E E E E Errzkeras.ops.image.map_coordinatesct||fr%t|||||Stj|||||S)aMap the input array to new coordinates by interpolation.. Note that interpolation near boundaries differs from the scipy function, because we fixed an outstanding bug [scipy/issues/2640](https://github.com/scipy/scipy/issues/2640). Args: input: The input array. coordinates: The coordinates at which input is evaluated. order: The order of the spline interpolation. The order must be `0` or `1`. `0` indicates the nearest neighbor and `1` indicates the linear interpolation. fill_mode: Points outside the boundaries of the input are filled according to the given mode. Available methods are `"constant"`, `"nearest"`, `"wrap"` and `"mirror"` and `"reflect"`. Defaults to `"constant"`. - `"constant"`: `(k k k k | a b c d | k k k k)` The input is extended by filling all values beyond the edge with the same constant value k specified by `fill_value`. - `"nearest"`: `(a a a a | a b c d | d d d d)` The input is extended by the nearest pixel. - `"wrap"`: `(a b c d | a b c d | a b c d)` The input is extended by wrapping around to the opposite edge. - `"mirror"`: `(c d c b | a b c d | c b a b)` The input is extended by mirroring about the edge. - `"reflect"`: `(d c b a | a b c d | d c b a)` The input is extended by reflecting about the edge of the last pixel. fill_value: Value used for points outside the boundaries of the input if `fill_mode="constant"`. Defaults to `0`. Returns: Output image or batch of images. )rrr3rrr)inputrrr@rAs rrr\sqPUK011,      -{ + +  , = ( (     rc8eZdZ dfd ZdZdZxZS) PadImagesNct||_||_||_||_||_||_dSr)rr top_paddingbottom_padding left_padding right_padding target_height target_width)rrrrrrrrs rrzPadImages.__init__sQ &,(**(rc ht||j|j|j|j|j|jSr) _pad_imagesrrrrrrrimagess rrzPadImages.calls;                rctj|}|j4t|dkrdnd}|j||z|jz|_|j4t|dkrdnd}|j||z|jz|_|d|j|j|df}t|dkr |dd}t||j S)Nrrr#r&r!rb) rr(rr'rrrrrrr%)rr images_shape height_axis width_axisrgs rr*zPadImages.compute_output_specs y((   %"<00A55!!1K {+,%&     $!,//144!J!z*+$%   O        |   ! !!!"" I,    rNNNNNNr,r1s@rrrso))))))"           rrzkeras.ops.image.pad_imagesc t|fr't|||||||St|||||||S)aPad `images` with zeros to the specified `height` and `width`. Args: images: 4D Tensor of shape `(batch, height, width, channels)` or 3D Tensor of shape `(height, width, channels)`. top_padding: Number of rows of zeros to add on top. bottom_padding: Number of rows of zeros to add at the bottom. left_padding: Number of columns of zeros to add on the left. right_padding: Number of columns of zeros to add on the right. target_height: Height of output images. target_width: Width of output images. Returns: If `images` were 4D, a 4D float Tensor of shape `(batch, target_height, target_width, channels)` If `images` were 3D, a 3D float Tensor of shape `(target_height, target_width, channels)` Example: >>> images = np.random.random((15, 25, 3)) >>> padded_images = keras.ops.image.pad_images( ... images, 2, 3, target_height=20, target_width=30 ... ) >>> padded_images.shape (20, 30, 3) >>> batch_images = np.random.random((2, 15, 25, 3)) >>> padded_batch = keras.ops.image.pad_images( ... batch_images, 2, 3, target_height=20, target_width=30 ... ) >>> padded_batch.shape (2, 20, 30, 3))rrr3r)rrrrrrrs r pad_imagesrssXVI&&           -      rc tj|}d}tj|}t |dkr#d}tj|d}n%t |dkrtd|tj|\} } } } |||gddkrtd|d |d ||||gddkrtd |d |d ||||z | z }|||z | z }|||z | z }|||z | z }|dkrtd||dkrtd||dkrtd||dkrtd|tj tj dd||||ddgddg} tj || }||| z|z}||| z|z}| ||| g}tj ||}|s"tj |dg}|S)NTrFrrVInvalid shape for argument `images`: it must have rank 3 or 4. Received: images.shape=r#z^Must specify exactly two of top_padding, bottom_padding, target_height. Received: top_padding=z, bottom_padding=, target_height=z^Must specify exactly two of left_padding, right_padding, target_width. Received: left_padding=z, right_padding=, target_width=z0top_padding must be >= 0. Received: top_padding=z2left_padding must be >= 0. Received: left_padding=z4right_padding must be >= 0. Received: right_padding=z6bottom_padding must be >= 0. Received: bottom_padding=r&rm) rconvert_to_tensorrr(r'rrrur)countrtstackpadrx)rrrrrrris_batchrbatchheightwidthdepthpaddingspadded padded_shapes rrrsd &v . .FH9V$$L <A**6155 \  a   5&2 5 5   #&)F"3"3E65%^]399$??1DD -%0 - -- - -+  - -    m\288>>!CC +&2 + ++ + +)  + +   #n4v= &4v=#m3e; $|3e; Q O+ O O   a 5&2 5 5   q 7'4 7 7    9(6 9 9   }$$    AH]  vx 0 0F#f,~= #e+m; =,>L ] " "6< 8 8F 9&&vQC&88 Mrc*eZdZfdZdZdZxZS) CropImagesct||_||_||_||_||_||_dSr)rr top_croppingbottom_cropping left_croppingright_croppingrr)rrrrrrrrs rrzCropImages.__init__ssQ (.*,*(rc ht||j|j|j|j|j|jSr) _crop_imagesrrrrrrrs rrzCropImages.calls;               rctj|}|d|j|j|df}|j4t |dkrdnd}|j||z |jz |_|j4t |dkrdnd}|j||z |jz |_|d|j|j|df}t |dkr |dd}t||j S)Nrr!rr#r&rb) rr(rrr'rrrrrr%)rrrrgrrs rr*zCropImages.compute_output_specs0y(( O          %"<00A55!!1K!{+,&'     $!,//144!J"z*+%&   O        |   ! !!!"" I,    rr,r1s@rrrrsV)))))"    ! ! ! ! ! ! ! rrzkeras.ops.image.crop_imagesc t|fr't|||||||St|||||||S)aCrop `images` to a specified `height` and `width`. Args: images: 4-D batch of images of shape `(batch, height, width, channels)` or 3-D single image of shape `(height, width, channels)`. top_cropping: Number of columns to crop from the top. bottom_cropping: Number of columns to crop from the bottom. left_cropping: Number of columns to crop from the left. right_cropping: Number of columns to crop from the right. target_height: Height of the output images. target_width: Width of the output images. Returns: If `images` were 4D, a 4D float Tensor of shape `(batch, target_height, target_width, channels)` If `images` were 3D, a 3D float Tensor of shape `(target_height, target_width, channels)` Example: >>> images = np.reshape(np.arange(1, 28, dtype="float32"), [3, 3, 3]) >>> images[:,:,0] # print the first channel of the images array([[ 1., 4., 7.], [10., 13., 16.], [19., 22., 25.]], dtype=float32) >>> cropped_images = keras.image.crop_images(images, 0, 0, 2, 2) >>> cropped_images[:,:,0] # print the first channel of the cropped images array([[ 1., 4.], [10., 13.]], dtype=float32))rrr3r)rrrrrrrs r crop_imagesrssPVI&&           -      rc ftj|}d}tj|}t |dkr#d}tj|d}n%t |dkrtd|tj|\} } } } |||gddkrtd|d |d ||||gddkrtd |d |d ||| |z |z }|| |z |z }|| |z |z }|| |z |z }|dkrtd||dkrtd||dkrtd||dkrtd|tj |tj d||dgtj | ||| g} | ||| g}tj | |} |s"tj | dg} | S)NTrFrrrr#zaMust specify exactly two of top_cropping, bottom_cropping, target_height. Received: top_cropping=z, bottom_cropping=rzaMust specify exactly two of left_cropping, right_cropping, target_width. Received: left_cropping=z, right_cropping=rz2top_cropping must be >= 0. Received: top_cropping=z4target_height must be >= 0. Received: target_height=z4left_cropping must be >= 0. Received: left_cropping=z2target_width must be >= 0. Received: target_width=rm) rrrr(r'rrrur)rslicerrtrx)rrrrrrrrrrrrrcropped cropped_shapes rrrs& &v . .FH9V$$L <A**6155 \  a   5&2 5 5   #&)F"3"3E65%o}5;;DAAQFF -&2 - - / - -+  - -    ~|4::4@@AEE +'4 + +- + +)  + +    -? 0<?  ,~= ~- = a 5&2 5 5   q 7'4 7 7   q 7'4 7 7   a 5&2 5 5   i Q mQ?@@ UM<GHHG M<?Mm##G];;G ;-''qc':: Nrr+rFrRrh)r7rr) keras.srcrrkeras.src.api_exportrkeras.src.backendrrkeras.src.ops.operationrkeras.src.ops.operation_utilsr r rr5rDrJrNrUrjr_rrrrrrrrrrrs------))))))222222------CCCCCC)))))Y)))X011 111211h7 7 7 7 7 Y7 7 7 t&''ggg('gT%;%;%;%;%;i%;%;%;P011 aaa21aH3?3?3?3?3?Y3?3?3?l/00   888108|   ****ZEEEEEYEEE@/00@A333103l8 8 8 8 8 8 8 8 v*++===,+=@```F> > > > > > > > B+,,999-,9xRRRRRr