tf.image - LostTech.TensorFlow Documentation

object adjust_brightness(IGraphNodeBase image, IGraphNodeBase delta)

Adjust 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 `[0,1)`, as it is added to the image in floating point representation, where pixel values are in the `[0,1)` range.

Parameters

IGraphNodeBase image: RGB image or images to adjust.
IGraphNodeBase delta: A scalar. Amount to add to the pixel values.

Returns

object: A brightness-adjusted tensor of the same shape and type as `image`.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_brightness(x, delta=0.1) ```

object adjust_brightness(IGraphNodeBase image, double delta)

Adjust 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 `[0,1)`, as it is added to the image in floating point representation, where pixel values are in the `[0,1)` range.

Parameters

IGraphNodeBase image: RGB image or images to adjust.
double delta: A scalar. Amount to add to the pixel values.

Returns

object: A brightness-adjusted tensor of the same shape and type as `image`.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_brightness(x, delta=0.1) ```

object adjust_brightness_dyn(object image, object delta)

Adjust 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 `[0,1)`, as it is added to the image in floating point representation, where pixel values are in the `[0,1)` range.

Parameters

object image: RGB image or images to adjust.
object delta: A scalar. Amount to add to the pixel values.

Returns

object: A brightness-adjusted tensor of the same shape and type as `image`.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_brightness(x, delta=0.1) ```

object adjust_contrast(IGraphNodeBase images, double contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

IGraphNodeBase images: Images to adjust. At least 3-D.
double contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_contrast(IGraphNodeBase images, IGraphNodeBase contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

IGraphNodeBase images: Images to adjust. At least 3-D.
IGraphNodeBase contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_contrast(IGraphNodeBase images, IEnumerable<double> contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

IGraphNodeBase images: Images to adjust. At least 3-D.
IEnumerable<double> contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_contrast(ValueTuple<PythonClassContainer, PythonClassContainer> images, IGraphNodeBase contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

ValueTuple<PythonClassContainer, PythonClassContainer> images: Images to adjust. At least 3-D.
IGraphNodeBase contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_contrast(ValueTuple<PythonClassContainer, PythonClassContainer> images, IEnumerable<double> contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

ValueTuple<PythonClassContainer, PythonClassContainer> images: Images to adjust. At least 3-D.
IEnumerable<double> contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_contrast(ValueTuple<PythonClassContainer, PythonClassContainer> images, double contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

ValueTuple<PythonClassContainer, PythonClassContainer> images: Images to adjust. At least 3-D.
double contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_contrast_dyn(object images, object contrast_factor)

Adjust contrast of RGB or grayscale images.

This is a convenience method that converts RGB images to float representation, adjusts their contrast, 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.

`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`.

Parameters

object images: Images to adjust. At least 3-D.
object contrast_factor: A float multiplier for adjusting contrast.

Returns

object: The contrast-adjusted image or images.
Usage Example: ```python import tensorflow as tf x = tf.random.normal(shape=(256, 256, 3)) tf.image.adjust_contrast(x,2) ```

object adjust_gamma(IGraphNodeBase image, int gamma, int gain)

Performs 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.

Returns

object: A Tensor. A Gamma-adjusted tensor of the same shape and type as `image`. Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_gamma(x, 0.2) ```

object adjust_gamma(IGraphNodeBase image, double gamma, int gain)

Performs 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.

Returns

object: A Tensor. A Gamma-adjusted tensor of the same shape and type as `image`. Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_gamma(x, 0.2) ```

object adjust_gamma(IGraphNodeBase image, IGraphNodeBase gamma, int gain)

Performs 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.

Returns

object: A Tensor. A Gamma-adjusted tensor of the same shape and type as `image`. Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_gamma(x, 0.2) ```

object adjust_gamma_dyn(object image, ImplicitContainer<T> gamma, ImplicitContainer<T> gain)

Performs 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.

Returns

object: A Tensor. A Gamma-adjusted tensor of the same shape and type as `image`. Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_gamma(x, 0.2) ```

object adjust_hue(ValueTuple<PythonClassContainer, PythonClassContainer> image, double delta, string name)

Adjust hue of RGB images.

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(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]`.

Parameters

ValueTuple<PythonClassContainer, PythonClassContainer> image: RGB image or images. Size of the last dimension must be 3.
double delta: float. How much to add to the hue channel.
string name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_hue(x, 0.2) ```

object adjust_hue(ValueTuple<PythonClassContainer, PythonClassContainer> image, IGraphNodeBase delta, string name)

Adjust hue of RGB images.

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(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]`.

Parameters

ValueTuple<PythonClassContainer, PythonClassContainer> image: RGB image or images. Size of the last dimension must be 3.
IGraphNodeBase delta: float. How much to add to the hue channel.
string name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_hue(x, 0.2) ```

object adjust_hue(IndexedSlices image, double delta, string name)

Adjust hue of RGB images.

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(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]`.

Parameters

IndexedSlices image: RGB image or images. Size of the last dimension must be 3.
double delta: float. How much to add to the hue channel.
string name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_hue(x, 0.2) ```

object adjust_hue(IndexedSlices image, IGraphNodeBase delta, string name)

Adjust hue of RGB images.

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(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]`.

Parameters

IndexedSlices image: RGB image or images. Size of the last dimension must be 3.
IGraphNodeBase delta: float. How much to add to the hue channel.
string name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_hue(x, 0.2) ```

object adjust_hue(IGraphNodeBase image, double delta, string name)

Adjust hue of RGB images.

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(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]`.

Parameters

IGraphNodeBase image: RGB image or images. Size of the last dimension must be 3.
double delta: float. How much to add to the hue channel.
string name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_hue(x, 0.2) ```

object adjust_jpeg_quality(IGraphNodeBase image, IGraphNodeBase jpeg_quality, string name)

Adjust jpeg encoding quality of an RGB image.

This is a convenience method that adjusts jpeg encoding quality of an RGB image.

`image` is an RGB image. The image's encoding quality is adjusted to `jpeg_quality`. `jpeg_quality` must be in the interval `[0, 100]`.

Parameters

IGraphNodeBase image: RGB image or images. Size of the last dimension must be 3.
IGraphNodeBase jpeg_quality: Python int or Tensor of type int32. jpeg encoding quality.
string name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_jpeg_quality(x, 75) ```

object adjust_jpeg_quality_dyn(object image, object jpeg_quality, object name)

Adjust jpeg encoding quality of an RGB image.

This is a convenience method that adjusts jpeg encoding quality of an RGB image.

`image` is an RGB image. The image's encoding quality is adjusted to `jpeg_quality`. `jpeg_quality` must be in the interval `[0, 100]`.

Parameters

object image: RGB image or images. Size of the last dimension must be 3.
object jpeg_quality: Python int or Tensor of type int32. jpeg encoding quality.
object name: A name for this operation (optional).

Returns

object: Adjusted image(s), same shape and DType as `image`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_jpeg_quality(x, 75) ```

object adjust_saturation(IGraphNodeBase image, double saturation_factor, string name)

Adjust saturation of RGB images.

This is a convenience method that converts RGB images to float representation, converts them 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.

`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.

Parameters

IGraphNodeBase image: RGB image or images. Size of the last dimension must be 3.
double saturation_factor: float. Factor to multiply the saturation by.
string name: A name for this operation (optional).

Returns

object

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

Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.adjust_saturation(x, 0.5) ```

object central_crop(ndarray image, double central_fraction)

Crop 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.

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).

Parameters

ndarray image: Either a 3-D float Tensor of shape [height, width, depth], or a 4-D Tensor of shape [batch_size, height, width, depth].
double central_fraction: float (0, 1], fraction of size to crop Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.central_crop(x, 0.5) ```

Returns

object: 3-D / 4-D float Tensor, as per the input.

object central_crop(IGraphNodeBase image, double central_fraction)

Crop 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.

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).

Parameters

IGraphNodeBase image: Either a 3-D float Tensor of shape [height, width, depth], or a 4-D Tensor of shape [batch_size, height, width, depth].
double central_fraction: float (0, 1], fraction of size to crop Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.central_crop(x, 0.5) ```

Returns

object: 3-D / 4-D float Tensor, as per the input.

object central_crop(ValueTuple<PythonClassContainer, PythonClassContainer> image, double central_fraction)

Crop 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.

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).

Parameters

ValueTuple<PythonClassContainer, PythonClassContainer> image: Either a 3-D float Tensor of shape [height, width, depth], or a 4-D Tensor of shape [batch_size, height, width, depth].
double central_fraction: float (0, 1], fraction of size to crop Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.central_crop(x, 0.5) ```

Returns

object: 3-D / 4-D float Tensor, as per the input.

object central_crop_dyn(object image, object central_fraction)

Crop 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.

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).

Parameters

object image: Either a 3-D float Tensor of shape [height, width, depth], or a 4-D Tensor of shape [batch_size, height, width, depth].
object central_fraction: float (0, 1], fraction of size to crop Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3)) >> tf.image.central_crop(x, 0.5) ```

Returns

object: 3-D / 4-D float Tensor, as per the input.

object combined_non_max_suppression(object boxes, object scores, IGraphNodeBase max_output_size_per_class, IGraphNodeBase max_total_size, double iou_threshold, IGraphNodeBase score_threshold, bool pad_per_class, bool clip_boxes, string name)

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.

Parameters

object 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.
object 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).
IGraphNodeBase max_output_size_per_class: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression per class
IGraphNodeBase max_total_size: A scalar representing maximum number of boxes retained over all classes.
double iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU.
IGraphNodeBase score_threshold: A float representing the threshold for deciding when to remove boxes based on score.
bool 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.
bool 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.
string name: A name for the operation (optional).

Returns

object: '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.

object combined_non_max_suppression(object boxes, object scores, IGraphNodeBase max_output_size_per_class, IGraphNodeBase max_total_size, IGraphNodeBase iou_threshold, ImplicitContainer<T> score_threshold, bool pad_per_class, bool clip_boxes, string name)

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.

Parameters

object 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.
object 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).
IGraphNodeBase max_output_size_per_class: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression per class
IGraphNodeBase max_total_size: A scalar representing maximum number of boxes retained over all classes.
IGraphNodeBase iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU.
ImplicitContainer<T> score_threshold: A float representing the threshold for deciding when to remove boxes based on score.
bool 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.
bool 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.
string name: A name for the operation (optional).

Returns

object: '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.

object combined_non_max_suppression(object boxes, object scores, IGraphNodeBase max_output_size_per_class, IGraphNodeBase max_total_size, IGraphNodeBase iou_threshold, IGraphNodeBase score_threshold, bool pad_per_class, bool clip_boxes, string name)

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.

Parameters

object 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.
object 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).
IGraphNodeBase max_output_size_per_class: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression per class
IGraphNodeBase max_total_size: A scalar representing maximum number of boxes retained over all classes.
IGraphNodeBase iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU.
IGraphNodeBase score_threshold: A float representing the threshold for deciding when to remove boxes based on score.
bool 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.
bool 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.
string name: A name for the operation (optional).

Returns

object: '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.

object combined_non_max_suppression(object boxes, object scores, IGraphNodeBase max_output_size_per_class, IGraphNodeBase max_total_size, double iou_threshold, ImplicitContainer<T> score_threshold, bool pad_per_class, bool clip_boxes, string name)

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.

Parameters

object 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.
object 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).
IGraphNodeBase max_output_size_per_class: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression per class
IGraphNodeBase max_total_size: A scalar representing maximum number of boxes retained over all classes.
double iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU.
ImplicitContainer<T> score_threshold: A float representing the threshold for deciding when to remove boxes based on score.
bool 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.
bool 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.
string name: A name for the operation (optional).

Returns

object: '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.

object combined_non_max_suppression_dyn(object boxes, object scores, object max_output_size_per_class, object max_total_size, ImplicitContainer<T> iou_threshold, ImplicitContainer<T> score_threshold, ImplicitContainer<T> pad_per_class, ImplicitContainer<T> clip_boxes, object name)

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.

Parameters

object 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.
object 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).
object max_output_size_per_class: A scalar integer `Tensor` representing the maximum number of boxes to be selected by non max suppression per class
object max_total_size: A scalar representing maximum number of boxes retained over all classes.
ImplicitContainer<T> iou_threshold: A float representing the threshold for deciding whether boxes overlap too much with respect to IOU.
ImplicitContainer<T> score_threshold: A float representing the threshold for deciding when to remove boxes based on score.
ImplicitContainer<T> 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.
ImplicitContainer<T> 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.
object name: A name for the operation (optional).

Returns

object: '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.

object convert_image_dtype(object image, DType dtype, bool saturate, string name)

Convert `image` to `dtype`, scaling its values if needed.

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).

Parameters

object image: An image.
DType dtype: A `DType` to convert `image` to.
bool saturate: If `True`, clip the input before casting (if necessary).
string name: A name for this operation (optional).

Returns

object: `image`, converted to `dtype`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3), dtype=tf.float32) >> tf.image.convert_image_dtype(x, dtype=tf.float16, saturate=False) ```

object convert_image_dtype(object image, DType dtype, bool saturate, PythonFunctionContainer name)

Convert `image` to `dtype`, scaling its values if needed.

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).

Parameters

object image: An image.
DType dtype: A `DType` to convert `image` to.
bool saturate: If `True`, clip the input before casting (if necessary).
PythonFunctionContainer name: A name for this operation (optional).

Returns

object: `image`, converted to `dtype`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3), dtype=tf.float32) >> tf.image.convert_image_dtype(x, dtype=tf.float16, saturate=False) ```

object convert_image_dtype_dyn(object image, object dtype, ImplicitContainer<T> saturate, object name)

Convert `image` to `dtype`, scaling its values if needed.

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).

Parameters

object image: An image.
object dtype: A `DType` to convert `image` to.
ImplicitContainer<T> saturate: If `True`, clip the input before casting (if necessary).
object name: A name for this operation (optional).

Returns

object: `image`, converted to `dtype`.
Usage Example: ```python >> import tensorflow as tf >> x = tf.random.normal(shape=(256, 256, 3), dtype=tf.float32) >> tf.image.convert_image_dtype(x, dtype=tf.float16, saturate=False) ```

Tensor crop_and_resize(IGraphNodeBase image, IGraphNodeBase boxes, IGraphNodeBase box_ind, IEnumerable<object> crop_size, string method, int extrapolation_value, string name, object box_indices)

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.

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.image.resize_bilinear()` or `tf.image.resize_nearest_neighbor()`(depends on the `method` argument) with `align_corners=True`.

Parameters

IGraphNodeBase image: A `Tensor`. Must be one of the following types: `uint8`, `uint16`, `int8`, `int16`, `int32`, `int64`, `half`, `float32`, `float64`. A 4-D tensor of shape `[batch, image_height, image_width, depth]`. Both `image_height` and `image_width` need to be positive.
IGraphNodeBase boxes: A `Tensor` of type `float32`. 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.
IGraphNodeBase box_ind: A `Tensor` of type `int32`. 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.
IEnumerable<object> crop_size: A `Tensor` of type `int32`. 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.
string method: An optional `string` from: `"bilinear", "nearest"`. Defaults to `"bilinear"`. A 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.
int extrapolation_value: An optional `float`. Defaults to `0`. Value used for extrapolation, when applicable.
string name: A name for the operation (optional).
object box_indices

Returns

Tensor: A `Tensor` of type `float32`.

object crop_and_resize_dyn(object image, object boxes, object box_ind, object crop_size, ImplicitContainer<T> method, ImplicitContainer<T> extrapolation_value, object name, object box_indices)

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.

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.image.resize_bilinear()` or `tf.image.resize_nearest_neighbor()`(depends on the `method` argument) with `align_corners=True`.

Parameters

object image: A `Tensor`. Must be one of the following types: `uint8`, `uint16`, `int8`, `int16`, `int32`, `int64`, `half`, `float32`, `float64`. A 4-D tensor of shape `[batch, image_height, image_width, depth]`. Both `image_height` and `image_width` need to be positive.
object boxes: A `Tensor` of type `float32`. 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.
object box_ind: A `Tensor` of type `int32`. 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.
object crop_size: A `Tensor` of type `int32`. 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.
ImplicitContainer<T> method: An optional `string` from: `"bilinear", "nearest"`. Defaults to `"bilinear"`. A 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.
ImplicitContainer<T> extrapolation_value: An optional `float`. Defaults to `0`. Value used for extrapolation, when applicable.
object name: A name for the operation (optional).
object box_indices

Returns

object: A `Tensor` of type `float32`.

Tensor crop_to_bounding_box(PythonClassContainer image, int offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

PythonClassContainer image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(PythonClassContainer image, int offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

PythonClassContainer image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IGraphNodeBase image, int offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IGraphNodeBase image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(PythonClassContainer image, IGraphNodeBase offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

PythonClassContainer image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IGraphNodeBase image, IGraphNodeBase offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IGraphNodeBase image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(PythonClassContainer image, IGraphNodeBase offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

PythonClassContainer image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IGraphNodeBase image, int offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IGraphNodeBase image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IGraphNodeBase image, IGraphNodeBase offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IGraphNodeBase image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(CompositeTensor image, IGraphNodeBase offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

CompositeTensor image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(CompositeTensor image, IGraphNodeBase offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

CompositeTensor image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(CompositeTensor image, int offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

CompositeTensor image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IEnumerable<PythonClassContainer> image, IGraphNodeBase offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IEnumerable<PythonClassContainer> image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IEnumerable<PythonClassContainer> image, IGraphNodeBase offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IEnumerable<PythonClassContainer> image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
IGraphNodeBase offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(CompositeTensor image, int offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

CompositeTensor image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IEnumerable<PythonClassContainer> image, int offset_height, IGraphNodeBase offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IEnumerable<PythonClassContainer> image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
IGraphNodeBase offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

Tensor crop_to_bounding_box(IEnumerable<PythonClassContainer> image, int offset_height, int offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

IEnumerable<PythonClassContainer> image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
int offset_height: Vertical coordinate of the top-left corner of the result in the input.
int offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

Tensor: 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]`

object crop_to_bounding_box_dyn(object image, object offset_height, object offset_width, object target_height, object target_width)

Crops an image to a specified bounding box.

This op cuts a rectangular part out of `image`. The top-left corner of the returned image is at `offset_height, offset_width` in `image`, and its lower-right corner is at `offset_height + target_height, offset_width + target_width`.

Parameters

object image: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor of shape `[height, width, channels]`.
object offset_height: Vertical coordinate of the top-left corner of the result in the input.
object offset_width: Horizontal coordinate of the top-left corner of the result in the input.
object target_height: Height of the result.
object target_width: Width of the result.

Returns

object: 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]`

Tensor draw_bounding_boxes(IGraphNodeBase images, IGraphNodeBase boxes, string name, ndarray colors)

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 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.

Parameters

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

Returns

Tensor: A `Tensor`. Has the same type as `images`.

Tensor encode_png(IGraphNodeBase image, int compression, string name)

PNG-encode an image.

`image` is a 3-D uint8 or uint16 Tensor of shape `[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.

Parameters

IGraphNodeBase image: A `Tensor`. Must be one of the following types: `uint8`, `uint16`. 3-D with shape `[height, width, channels]`.
int compression: An optional `int`. Defaults to `-1`. Compression level.
string name: A name for the operation (optional).

Returns

Tensor: A `Tensor` of type `string`.

object encode_png_dyn(object image, ImplicitContainer<T> compression, object name)

PNG-encode an image.

`image` is a 3-D uint8 or uint16 Tensor of shape `[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.

Parameters

object image: A `Tensor`. Must be one of the following types: `uint8`, `uint16`. 3-D with shape `[height, width, channels]`.
ImplicitContainer<T> compression: An optional `int`. Defaults to `-1`. Compression level.
object name: A name for the operation (optional).

Returns

object: A `Tensor` of type `string`.

Tensor extract_glimpse(IGraphNodeBase input, IGraphNodeBase size, IGraphNodeBase offsets, bool centered, bool normalized, bool uniform_noise, string name)

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.

Parameters

IGraphNodeBase input: A `Tensor` of type `float32`. A 4-D float tensor of shape `[batch_size, height, width, channels]`.
IGraphNodeBase 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.
IGraphNodeBase 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.
bool 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.
bool normalized: An optional `bool`. Defaults to `True`. indicates if the offset coordinates are normalized.
bool uniform_noise: An optional `bool`. Defaults to `True`. indicates if the noise should be generated using a uniform distribution or a Gaussian distribution.
string name: A name for the operation (optional).

Returns

Tensor: A `Tensor` of type `float32`.
Usage Example: ```python BATCH_SIZE = 1 IMAGE_HEIGHT = 3 IMAGE_WIDTH = 3 CHANNELS = 1 GLIMPSE_SIZE = (2, 2) image = tf.reshape(tf.range(9, delta=1, dtype=tf.float32), shape=(BATCH_SIZE, IMAGE_HEIGHT, IMAGE_WIDTH, CHANNELS)) output = tf.image.extract_glimpse(image, size=GLIMPSE_SIZE, offsets=[[1, 1]], centered=False, normalized=False) ```

Tensor extract_patches(object images, object sizes, object strides, object rates, object padding, string name)

Extract `patches` from `images`.

This op collects patches from the input image, as if applying a convolution. All extracted patches are stacked in the depth (last) dimension of the output.

Specifically, the op extracts patches of shape `sizes` which are `strides` apart in the input image. The output is subsampled using the `rates` argument, in the same manner as "atrous" or "dilated" convolutions.

The result is a 4D tensor which is indexed by batch, row, and column. `output[i, x, y]` contains a flattened patch of size `sizes[1], sizes[2]` which is taken from the input starting at `images[i, x*strides[1], y*strides[2]]`.

Each output patch can be reshaped to `sizes[1], sizes[2], depth`, where `depth` is `images.shape[3]`.

The output elements are taken from the input at intervals given by the `rate` argument, as in dilated convolutions.

The `padding` argument has no effect on the size of each patch, it determines how many patches are extracted. If `VALID`, only patches which are fully contained in the input image are included. If `SAME`, all patches whose starting point is inside the input are included, and areas outside the input default to zero.

Example:

``` n = 10 # images is a 1 x 10 x 10 x 1 array that contains the numbers 1 through 100 images = [[[[x * n + y + 1] for y in range(n)] for x in range(n)]]

# We generate two outputs as follows: # 1. 3x3 patches with stride length 5 # 2. Same as above, but the rate is increased to 2 tf.extract_image_patches(images=images, ksizes=[1, 3, 3, 1], strides=[1, 5, 5, 1], rates=[1, 1, 1, 1], padding='VALID')

# Yields: [[[[ 1 2 3 11 12 13 21 22 23] [ 6 7 8 16 17 18 26 27 28]] [[51 52 53 61 62 63 71 72 73] [56 57 58 66 67 68 76 77 78]]]] ```

If we mark the pixels in the input image which are taken for the output with `*`, we see the pattern:

``` * * * 4 5 * * * 9 10 * * * 14 15 * * * 19 20 * * * 24 25 * * * 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 * * * 54 55 * * * 59 60 * * * 64 65 * * * 69 70 * * * 74 75 * * * 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 ```

``` tf.extract_image_patches(images=images, sizes=[1, 3, 3, 1], strides=[1, 5, 5, 1], rates=[1, 2, 2, 1], padding='VALID')

# Yields: [[[[ 1 3 5 21 23 25 41 43 45] [ 6 8 10 26 28 30 46 48 50]]

[[ 51 53 55 71 73 75 91 93 95] [ 56 58 60 76 78 80 96 98 100]]]] ```

We can again draw the effect, this time using the symbols `*`, `x`, `+` and `o` to distinguish the patches:

``` * 2 * 4 * x 7 x 9 x 11 12 13 14 15 16 17 18 19 20 * 22 * 24 * x 27 x 29 x 31 32 33 34 35 36 37 38 39 40 * 42 * 44 * x 47 x 49 x + 52 + 54 + o 57 o 59 o 61 62 63 64 65 66 67 68 69 70 + 72 + 74 + o 77 o 79 o 81 82 83 84 85 86 87 88 89 90 + 92 + 94 + o 97 o 99 o ```

Parameters

object images: A 4-D Tensor with shape `[batch, in_rows, in_cols, depth]
object sizes: The size of the extracted patches. Must be [1, size_rows, size_cols, 1].
object strides: A 1-D Tensor of length 4. How far the centers of two consecutive patches are in the images. Must be: `[1, stride_rows, stride_cols, 1]`.
object rates: A 1-D Tensor of length 4. Must be: `[1, rate_rows, rate_cols, 1]`. This is the input stride, specifying how far two consecutive patch samples are in the input. Equivalent to extracting patches with `patch_sizes_eff = patch_sizes + (patch_sizes - 1) * (rates - 1)`, followed by subsampling them spatially by a factor of `rates`. This is equivalent to `rate` in dilated (a.k.a. Atrous) convolutions.
object padding: The type of padding algorithm to use.
string name: A name for the operation (optional).

Returns

Tensor: A 4-D Tensor of the same type as the input.

object extract_patches_dyn(object images, object sizes, object strides, object rates, object padding, object name)