Image
Resize
polyaxon.processing.image.Resize(mode, height, width, method=None, align_corners=False, name='Resize')
See plx.image.resize
's docstring
Transpose
polyaxon.processing.image.Transpose(mode, name='Transpose')
See plx.image.transpose
's docstring
Rotate90
polyaxon.processing.image.Rotate90(mode, k=1, is_random=False, seed=None, name='Rotate90')
See plx.image.rotate90
's docstring
ConvertColorSpace
polyaxon.processing.image.ConvertColorSpace(mode, from_space, to_space, name='ConvertColorSpace')
See plx.image.convert_color_space
's docstring
ConvertImagesDtype
polyaxon.processing.image.ConvertImagesDtype(mode, dtype, saturate=False, name='ConvertImagesDtype')
See plx.image.convert_images_dtype
's docstring
AdjustBrightness
polyaxon.processing.image.AdjustBrightness(mode, delta, is_random=False, seed=None, name='AdjustBrightness')
See plx.image.adjust_brightness
's docstring
AdjustContrast
polyaxon.processing.image.AdjustContrast(mode, contrast_factor, contrast_factor_max=None, is_random=False, seed=None, name='AdjustContrast')
See plx.image.adjust_contrast
's docstring
AdjustHue
polyaxon.processing.image.AdjustHue(mode, delta, is_random=False, seed=None, name='AdjustHue')
See plx.image.adjust_hue
's docstring
AdjustSaturation
polyaxon.processing.image.AdjustSaturation(mode, saturation_factor, saturation_factor_max=None, is_random=False, seed=None, name='AdjustSaturation')
See plx.image.adjust_saturation
's docstring
AdjustGamma
polyaxon.processing.image.AdjustGamma(mode, gamma=1, gain=1, name='AdjustGamma')
See plx.image.adjust_gamma
's docstring
Standardization
polyaxon.processing.image.Standardization(mode, name='Standardization')
See plx.image.standardize
's docstring
DrawBoundingBoxes
polyaxon.processing.image.DrawBoundingBoxes(mode, boxes, name='DrawBoundingBoxes')
See plx.image.draw_bounding_boxes
's docstring
TotalVariation
polyaxon.processing.image.TotalVariation(mode, name='TotalVariation')
See plx.image.total_variation
's docstring
ExtractGlimpse
polyaxon.processing.image.ExtractGlimpse(mode, size, offsets, centered=None, normalized=None, uniform_noise=None, name='ExtractGlimpse')
See plx.image.extract_glimpse
's docstring
ToBoundingBox
polyaxon.processing.image.ToBoundingBox(mode, offset_height, offset_width, target_height, target_width, method='crop', name='ToBoundingBox')
See plx.image.to_bounding_box
's docstring
Flip
polyaxon.processing.image.Flip(mode, axis=0, is_random=False, seed=None, name='Flip')
See plx.image.flip
's docstring
CentralCrop
polyaxon.processing.image.CentralCrop(mode, central_fraction, name='CentralCrop')
See plx.image.central_crop
's docstring
RandomCrop
polyaxon.processing.image.RandomCrop(mode, height, width, name='RandomCrop')
See plx.image.random_crop
's docstring
resize
resize(images, height, width, method=None, align_corners=False)
Resize images
to size
using the specified method
.
(A mirror to tf.image resize_images and resize_image_with_crop_or_pad)

If method is None: Resizes an image to a target width and height by either centrally cropping the image or padding it evenly with zeros. If
width
orheight
is greater than the specifiedtarget_width
ortarget_height
respectively, this op centrally crops along that dimension. Ifwidth
orheight
is smaller than the specifiedtarget_width
ortarget_height
respectively, this op centrally pads with 0 along that dimension. 
If method is not None: the resized images will be distorted if their original aspect ratio is not the same as
size
.
method
can be one of:
None
no distortion.ResizeMethod.BILINEAR
: Bilinear interpolation.ResizeMethod.NEAREST_NEIGHBOR
: Nearest neighbor interpolation.ResizeMethod.BICUBIC
: Bicubic interpolation.
ResizeMethod.AREA
: Area interpolation. 
Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.  height: int32 Target height.
 width: int32 Target width.
 method: ResizeMethod. Defaults to
ResizeMethod.BILINEAR
. Possible values: BILINEAR, NEAREST_NEIGHBOR, BICUBIC, AREA  align_corners: bool. If true, exactly align all 4 corners of the input and output.
Only used if method is not None. Defaults to
false
.
 images: 4D Tensor of shape

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.
 ValueError: if the shape of

Returns: If
images
was 4D, a 4D float Tensor of shape[batch, new_height, new_width, channels]
. Ifimages
was 3D, a 3D float Tensor of shape[new_height, new_width, channels]
.
central_crop
central_crop(images, central_fraction)
Crop the central region of the image. (A mirror to tf.image central_crop)
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.
 ........ ..XXXX.. ..XXXX.. ........ where "X" is the central 50% of the image. 

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.  central_fraction: float (0, 1], fraction of size to crop
 images: 4D Tensor of shape

Raises:
 ValueError: if central_crop_fraction is not within (0, 1].

Returns: If
images
was 4D, a 4D float Tensor of shape[batch, new_height, new_width, channels]
. Ifimages
was 3D, a 3D float Tensor of shape[new_height, new_width, channels]
.
random_crop
random_crop(images, height, width)
Randomly crops an image/images to a given size.

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.  height:
float
. The height to crop to.  width:
float
. The width to crop to.
 images: 4D Tensor of shape

Returns: If
images
was 4D, a 4D float Tensor of shape[batch, new_height, new_width, channels]
. Ifimages
was 3D, a 3D float Tensor of shape[new_height, new_width, channels]
.
extract_glimpse
extract_glimpse(images, size, offsets, centered=None, normalized=None, uniform_noise=None, name=None)
Extracts a glimpse from the input tensor. (A mirror to tf.image extract_glimpse)
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 4D 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.

Args:
 images: A
Tensor
of typefloat32
. A 4D float tensor of shape[batch_size, height, width, channels]
.  size: A
Tensor
of typeint32
. A 1D 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 typefloat32
. A 2D integer tensor of shape[batch_size, 2]
containing the y, x locations of the center of each window.  centered: An optional
bool
. Defaults toTrue
. 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 toTrue
. indicates if the offset coordinates are normalized.  uniform_noise: An optional
bool
. Defaults toTrue
. indicates if the noise should be generated using a uniform distribution or a Gaussian distribution.  name: A name for the operation (optional).
 images: A

Returns: A
Tensor
of typefloat32
. A tensor representing the glimpses[batch_size, glimpse_height, glimpse_width, channels]
.
to_bounding_box
to_bounding_box(images, offset_height, offset_width, target_height, target_width, method='crop')
Pad/Crop image
with zeros to the specified height
and width
.
(A mirror to tf.image pad_to_bounding_box and crop_to_bounding_box)
If method == 'pad':
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`.
If method == 'crop': Crops an image to a specified bounding box.
This op cuts a rectangular part out of `image`. The topleft corner of the returned image is at `offset_height, offset_width` in `image`, and its lowerright corner is at `offset_height + target_height, offset_width + target_width`.

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.  offset_height:
 pad: Number of rows of zeros to add on top.
 crop: Vertical coordinate of the topleft corner of the result the input.
 offset_width:
 pad: Number of columns of zeros to add on the left.
 crop: Horizontal coordinate of the topleft corner of the result in the input.
 target_height: Height of output image.
 target_width: Width of output image.
 method:
crop
orpad
 images: 4D Tensor of shape

Returns: If
image
was 4D, a 4D float Tensor of shape[batch, target_height, target_width, channels]
Ifimage
was 3D, a 3D float Tensor of shape[target_height, target_width, channels]

Raises:
 ValueError: If the shape of
image
is incompatible with theoffset_*
ortarget_*
arguments, or eitheroffset_height
oroffset_width
is negative.
 ValueError: If the shape of
flip
flip(images, axis=0, is_random=False, seed=None)
Flip (randomly) an image/images. (A mirror to tf.image flip_left_right, flip_up_down, random_flip_left_right, and random_flip_up_down)
if axis is 0: * flip horizontally (left to right) if axis is 1: * vertically (upside down).
Outputs the contents of images
flipped along the given axis.

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.  axis:
int
. 0 for horizontal, 1 for vertical  is_random:
bool
, If True, flip randomly.  seed: A Python integer. Used to create a random seed. See @{tf.set_random_seed}.
 images: 4D Tensor of shape

Returns: If
image
was 4D, a 4D float Tensor of shape[batch, target_height, target_width, channels]
Ifimage
was 3D, a 3D float Tensor of shape `[target_height, target_width, channels] 
Raises:
 ValueError: if the shape of
image
not supported.
 ValueError: if the shape of
transpose
transpose(images)
Transpose an image/images by swapping the first and second dimension. (A mirror to tf.image transpose_image)

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.
 images: 4D Tensor of shape

Returns: If
image
was 4D, a 4D float Tensor of shape[batch, target_height, target_width, channels]
Ifimage
was 3D, a 3D float Tensor of shape `[target_height, target_width, channels] 
Raises:
 ValueError: if the shape of
image
not supported.
 ValueError: if the shape of
rotate90
rotate90(images, k=1, is_random=False, seed=None, name=None)
Rotate (randomly) images counterclockwise by 90 degrees. (A mirror to tf.image rot90)

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.  k: A scalar integer. The number of times the image is rotated by 90 degrees.
 is_random:
bool
, If True, adjust randomly.  seed: A Python integer. Used to create a random seed. See @{tf.set_random_seed}.
 name: A name for this operation (optional).
 images: 4D Tensor of shape

Returns: If
image
was 4D, a 4D float Tensor of shape[batch, target_height, target_width, channels]
Ifimage
was 3D, a 3D float Tensor of shape `[target_height, target_width, channels] 
Raises:
 ValueError: if the shape of
image
not supported.
 ValueError: if the shape of
adjust_saturation
adjust_saturation(images, saturation_factor, saturation_factor_max=None, is_random=False, seed=None, name=None)
Adjust (randomly) saturation of RGB images. (A mirror to tf.image adjust_saturation, random_saturation)
This is a convenience method that converts an RGB image to float representation, converts it to HSV, add 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.
The image saturation is adjusted by converting the images to HSV and
multiplying the saturation (S) channel by saturation_factor
and clipping.
The images is then converted back to RGB.
If is_random
is True
adjust saturation but uses a value randomly picked in
the interval [saturation_factor, saturation_factor_max]
.

Args:
 images: RGB image or images. Size of the last dimension must be 3.
 saturation_factor: float. Lower bound for the random saturation factor.
 saturation_factor_max: float. Upper bound for the random saturation factor.
 is_random:
bool
, If True, adjust randomly.  seed: An operationspecific seed. It will be used in conjunction with the graphlevel 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 graphlevel random seed.
 name: A name for this operation (optional).

Returns: Adjusted image(s), same shape and DType as
image
. 
Raises:
 ValueError: if
saturation_factor_max <= saturation_factor
ifsaturation_factor < 0
ifsaturation_factor_max is None (for random.)
 ValueError: if
adjust_gamma
adjust_gamma(image, gamma=1, gain=1)
Performs Gamma Correction on the input image. Also known as Power Law Transform. This function transforms the input image pixelwise according to the equation Out = In**gamma after scaling each pixel to the range 0 to 1. (A mirror to tf.image adjust_gamma)

Args: image : A Tensor. gamma : A scalar. Non negative real number. gain : A scalar. The constant multiplier.

Returns: A Tensor. Gamma corrected output image.

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: [1] http://en.wikipedia.org/wiki/Gamma_correction
standardize
standardize(images)
Linearly scales image
to have zero mean and unit norm.
(A mirror to tf.image per_image_standardization)
This op computes (x  mean) / adjusted_stddev
, where mean
is the average
of all values in image, and
adjusted_stddev = max(stddev, 1.0/sqrt(image.NumElements()))
.
stddev
is the standard deviation of all values in image
. It is capped
away from zero to protect against division by 0 when handling uniform images.

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
.
 images: 4D Tensor of shape

Returns: The standardized image with same shape as
image
. 
Raises:
 ValueError: if the shape of 'image' is incompatible with this function.
draw_bounding_boxes
draw_bounding_boxes(images, boxes, name=None)
Draw bounding boxes on a batch of images. (A mirror to tf.image draw_bounding_boxes)
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
height of the underlying image.
For example, if an image is 100 x 200 pixels and the bounding box is
[0.1, 0.2, 0.5, 0.9]
, the bottomleft and upperright coordinates of the
bounding box will be (10, 40)
to (50, 180)
.
Parts of the bounding box may fall outside the image.

Args:
 images: A
Tensor
. Must be one of the following types:float32
,half
. 4D with shape[batch, height, width, depth]
. A batch of images.  boxes: A
Tensor
of typefloat32
. 3D with shape[batch, num_bounding_boxes, 4]
containing bounding boxes.  name: A name for the operation (optional).
 images: A

Returns: A
Tensor
. Has the same type asimages
. 4D with the same shape asimages
. The batch of input images with bounding boxes drawn on the images.
non_max_suppression
non_max_suppression(boxes, scores, max_output_size, iou_threshold=None, name=None)
Greedily selects a subset of bounding boxes in descending order of score, pruning away boxes that have high intersectionoverunion (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.
(A mirror to tf.image non_max_suppression)
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:
 Examples:
>>> selected_indices = tf.image.non_max_suppression( ... boxes, scores, max_output_size, iou_threshold) >>> selected_boxes = tf.gather(boxes, selected_indices)

Args:
 boxes: A
Tensor
of typefloat32
. A 2D float tensor of shape[num_boxes, 4]
.  scores: A
Tensor
of typefloat32
. A 1D float tensor of shape[num_boxes]
representing a single score corresponding to each box (each row of boxes).  max_output_size: A
Tensor
of typeint32
. A scalar integer tensor representing the maximum number of boxes to be selected by non max suppression.  iou_threshold: An optional
float
. Defaults to0.5
. A float representing the threshold for deciding whether boxes overlap too much with respect to IOU.  name: A name for the operation (optional).
 boxes: A

Returns: A
Tensor
of typeint32
. A 1D integer tensor of shape[M]
representing the selected indices from the boxes tensor, whereM <= max_output_size
.
sample_distorted_bounding_box
sample_distorted_bounding_box(image_size, bounding_boxes, seed=None, seed2=None, min_object_covered=None, aspect_ratio_range=None, area_range=None, max_attempts=None, use_image_if_no_bounding_boxes=None, name=None)
Generate a single randomly distorted bounding box for an image.
Bounding box annotations are often supplied in addition to groundtruth 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.
(A mirror to tf.image sample_distorted_bounding_box)
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.
 Examples:
>>> # Generate a single distorted bounding box. >>> begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box( ... tf.shape(image), bounding_boxes=bounding_boxes) >>> # 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.image_summary('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
. 1D, containing[height, width, channels]
.  bounding_boxes: A
Tensor
of typefloat32
. 3D with shape[batch, N, 4]
describing the N bounding boxes associated with the image.  seed: An optional
int
. Defaults to0
. If eitherseed
orseed2
are set to nonzero, the random number generator is seeded by the givenseed
. Otherwise, it is seeded by a random seed.  seed2: An optional
int
. Defaults to0
. A second seed to avoid seed collision.  min_object_covered: An optional
float
. Defaults to0.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 nonnegative. 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 in this range.  max_attempts: An optional
int
. Defaults to100
. Number of attempts at generating a cropped region of the image of the specified constraints. Aftermax_attempts
failures, return the entire image.  use_image_if_no_bounding_boxes: An optional
bool
. Defaults toFalse
. 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).
 image_size: A

Returns: A tuple of
Tensor
objects (begin, size, bboxes). begin: A
Tensor
. Has the same type asimage_size
. 1D, containing[offset_height, offset_width, 0]
. Provide as input totf.slice
.  size: A
Tensor
. Has the same type asimage_size
. 1D, containing[target_height, target_width, 1]
. Provide as input totf.slice
.  bboxes: A
Tensor
of typefloat32
. 3D with shape[1, 1, 4]
containing the distorted bounding box. Provide as input totf.image.draw_bounding_boxes
.
 begin: A
total_variation
total_variation(images, name=None)
Calculate and return the total variation for one or more images.
(A mirror to tf.image total_variation)
The total variation is the sum of the absolute differences for neighboring pixelvalues in the input images. This measures how much noise is in the images.
This can be used as a lossfunction during optimization so as to suppress
noise in images. If you have a batch of images, then you should calculate
the scalar lossvalue as the sum:
loss = tf.reduce_sum(tf.image.total_variation(images))
This implements the anisotropic 2D version of the formula described here:

https://en.wikipedia.org/wiki/Total_variation_denoising

Args:

images: 4D Tensor of shape
[batch, height, width, channels]
or 3D Tensor of shape[height, width, channels]
. 
name: A name for the operation (optional).


Raises:
 ValueError: if images.shape is not a 3D or 4D vector.

Returns: The total variation of
images
.If
images
was 4D, return a 1D float Tensor of shape[batch]
with the total variation for each image in the batch. Ifimages
was 3D, return a scalar float with the total variation for that image.
convert_color_space
convert_color_space(images, from_space, to_space, name=None)
Converts one or more images from RGB to Grayscale. (A mirror to tf.image rgb_to_grayscale, rgb_to_hsv, grayscale_to_rgb, and hsv_to_rgb)
Outputs a tensor of the same DType
and rank as images
.
Possible conversions:
* rgb_to_grayscale: The size of the last dimension of the output is 1,
containing the Grayscale value of the pixels.
* grayscale_to_rgb: The size of the last dimension of the output is 3,
containing the RGB value of the pixels.
* hsv_to_rgb: The output is only well defined if the value in images
are in [0,1]
.
* rgb_to_hsv: The output is only well defined if the value in images
are in [0,1]
.
output[..., 0]
contains hue, output[..., 1]
contains saturation, and
output[..., 2]
contains value. All HSV values are in [0,1]
. A hue of 0
corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
* grayscale_to_hsv: grayscale_to_rgb then rgb_to_hsv
* hsv_to_grayscale: hsv_to_rgb then rgb_to_grayscale.

Args:
 images: 4D Tensor of shape
[batch, height, width, channels]
 from_space: The color to convert from.
 to_space: The color space to convert to.
 name: A name for the operation (optional).
 images: 4D Tensor of shape

Returns: The converted image(s).
convert_images_dtype
convert_images_dtype(images, dtype, saturate=False, name=None)
Convert image(s) to dtype
, scaling its values if needed.
(A mirror to tf.image convert_image_dtype)
Images that are represented using floating point values are expected to have
values in the range [0,1). Image data stored in integer data types are
expected to have values in the range [0,MAX]
, where MAX
is the largest
positive representable number for the data type.
This op converts between data types, scaling the values appropriately before casting.
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:
 images: An image.
 dtype: A
DType
to convertimage
to.  saturate: If
True
, clip the input before casting (if necessary).  name: A name for this operation (optional).

Returns:
image
, converted todtype
.
adjust_brightness
adjust_brightness(images, delta, is_random=False, seed=None)
Adjust (randomly) the brightness of RGB or Grayscale images. (A mirror to tf.image adjust_brightness, random_birightness)
This is a convenience method that converts an RGB image to float representation, adjusts its brightness, and then converts it 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
. Both
image
and delta
are converted to float
before adding (and image
is
scaled appropriately if it is in fixedpoint representation). For regular
images, delta
should be in the range [0,1)
, as it is added to the image in
floating point representation, where pixel values are in the [0,1)
range.
If is_random
is True
, adjust brightness using a value randomly picked in the
interval [delta, delta)
.

Args:
 images: A tensor.
 delta:
float
. Amount to add to the pixel values.  is_random:
bool
, If True, adjust randomly.  seed: A Python integer. Used to create a random seed. See @{tf.set_random_seed}.

Returns: A brightnessadjusted tensor of the same shape and type as
images
.
adjust_contrast
adjust_contrast(images, contrast_factor, contrast_factor_max=None, is_random=False, seed=None)
Adjust (randomly) the contrast of RGB or grayscale images by contrast factor. (A mirror to tf.image adjust_contrast, random_contrast)
This is a convenience method that converts an RGB image to float representation, adjusts its contrast, and then converts it back to the original data type. If several adjustments are chained it is advisable to minimize the number of redundant conversions.
images
is a tensor of at least 3 dimensions. The last 3 dimensions are
interpreted as [height, width, channels]
. The other dimensions only
represent a collection of images, such as [batch, height, width, channels].
Contrast is adjusted independently for each channel of each image.
For each channel, this Op computes the mean of the image pixels in the
channel and then adjusts each component x
of each pixel to
(x  mean) * contrast_factor + mean
.
If is_random
is True
: Equivalent to adjust_contrast()
but the value is
randomly picked in the interval [contrast_factor, contrast_factor_max]
.

Args:
 images:
tensor
. images tensor with 3 or more dimensions.  contrast_factor:
float
. Lower bound for the random contrast factor.  contrast_factor_max:
float
. Upper bound for the random contrast factor. Used for random adjustment.  is_random:
bool
, If True, adjust randomly.  seed: A Python integer. Used to create a random seed. See @{tf.set_random_seed}.
 images:

Returns: The contrastadjusted tensor.

Raises:
 ValueError: if
contrast_factor_max <= contrast_factor
ifcontrast_factor < 0
ifcontrast_factor_max
is None (for random.)
 ValueError: if
adjust_hue
adjust_hue(images, delta, is_random=False, seed=None, name=None)
Adjust (randomly) hue of an RGB images. (A mirror to tf.image adjust_hue, random_hue)
This is a convenience method that converts an RGB image to float representation, converts it to HSV, add 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 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]
.
If is_random
is True
adjust hue but uses a value randomly picked in
the interval [delta, delta]
.

Args:
 images: RGB image or images. Size of the last dimension must be 3.
 delta: float. How much to add to the hue channel.
 is_random:
bool
, If True, adjust randomly.  seed: A Python integer. Used to create a random seed. See @{tf.set_random_seed}.
 name: A name for this operation (optional).

Returns: Adjusted image(s), same shape and DType as
image
.