# Copyright 2015 The TensorFlow Authors. All Rights Reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

"""Implementation of image ops."""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import os

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import ops

from tensorflow.python.framework import tensor_shape

from tensorflow.python.framework import tensor_util

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import check_ops

from tensorflow.python.ops import clip_ops

from tensorflow.python.ops import control_flow_ops

from tensorflow.python.ops import gen_image_ops

from tensorflow.python.ops import gen_nn_ops

from tensorflow.python.ops import math_ops

from tensorflow.python.ops import random_ops

from tensorflow.python.ops import string_ops

from tensorflow.python.ops import variables

ops.NotDifferentiable('RandomCrop')

# TODO(b/31222613): This op may be differentiable, and there may be

# latent bugs here.

ops.NotDifferentiable('RGBToHSV')

# TODO(b/31222613): This op may be differentiable, and there may be

# latent bugs here.

ops.NotDifferentiable('HSVToRGB')

ops.NotDifferentiable('DrawBoundingBoxes')

ops.NotDifferentiable('SampleDistortedBoundingBox')

ops.NotDifferentiable('SampleDistortedBoundingBoxV2')

# TODO(bsteiner): Implement the gradient function for extract_glimpse

# TODO(b/31222613): This op may be differentiable, and there may be

# latent bugs here.

ops.NotDifferentiable('ExtractGlimpse')

ops.NotDifferentiable('NonMaxSuppression')

ops.NotDifferentiable('NonMaxSuppressionV2')

def _assert(cond, ex_type, msg):

"""A polymorphic assert, works with tensors and boolean expressions.

If `cond` is not a tensor, behave like an ordinary assert statement, except

that a empty list is returned. If `cond` is a tensor, return a list

containing a single TensorFlow assert op.

Args:

cond: Something evaluates to a boolean value. May be a tensor.

ex_type: The exception class to use.

msg: The error message.

Returns:

A list, containing at most one assert op.

"""

if _is_tensor(cond):

return [control_flow_ops.Assert(cond, [msg])]

else:

if not cond:

raise ex_type(msg)

else:

return []

def _is_tensor(x):

"""Returns `True` if `x` is a symbolic tensor-like object.

Args:

x: A python object to check.

Returns:

`True` if `x` is a `tf.Tensor` or `tf.Variable`, otherwise `False`.

"""

return isinstance(x, (ops.Tensor, variables.Variable))

def _ImageDimensions(image, rank):

"""Returns the dimensions of an image tensor.

Args:

image: A rank-D Tensor. For 3-D of shape: `[height, width, channels]`.

rank: The expected rank of the image

Returns:

A list of corresponding to the dimensions of the

input image. Dimensions that are statically known are python integers,

otherwise they are integer scalar tensors.

"""

if image.get_shape().is_fully_defined():

return image.get_shape().as_list()

else:

static_shape = image.get_shape().with_rank(rank).as_list()

dynamic_shape = array_ops.unstack(array_ops.shape(image), rank)

return [s if s is not None else d

for s, d in zip(static_shape, dynamic_shape)]

def _Check3DImage(image, require_static=True):

"""Assert that we are working with properly shaped image.

Args:

image: 3-D Tensor of shape [height, width, channels]

require_static: If `True`, requires that all dimensions of `image` are

known and non-zero.

Raises:

ValueError: if `image.shape` is not a 3-vector.

Returns:

An empty list, if `image` has fully defined dimensions. Otherwise, a list

containing an assert op is returned.

"""

try:

image_shape = image.get_shape().with_rank(3)

except ValueError:

raise ValueError("'image' (shape %s) must be three-dimensional." %

image.shape)

if require_static and not image_shape.is_fully_defined():

raise ValueError("'image' (shape %s) must be fully defined." %

image_shape)

if any(x == 0 for x in image_shape):

raise ValueError("all dims of 'image.shape' must be > 0: %s" %

image_shape)

if not image_shape.is_fully_defined():

return [check_ops.assert_positive(array_ops.shape(image),

["all dims of 'image.shape' "

"must be > 0."])]

else:

return []

def _CheckAtLeast3DImage(image, require_static=True):

"""Assert that we are working with properly shaped image.

Args:

image: >= 3-D Tensor of size [*, height, width, depth]

require_static: If `True`, requires that all dimensions of `image` are

known and non-zero.

Raises:

ValueError: if image.shape is not a [>= 3] vector.

Returns:

An empty list, if `image` has fully defined dimensions. Otherwise, a list

containing an assert op is returned.

"""

try:

if image.get_shape().ndims is None:

image_shape = image.get_shape().with_rank(3)

else:

image_shape = image.get_shape().with_rank_at_least(3)

except ValueError:

raise ValueError("'image' must be at least three-dimensional.")

if require_static and not image_shape.is_fully_defined():

raise ValueError('\'image\' must be fully defined.')

if any(x == 0 for x in image_shape):

raise ValueError('all dims of \'image.shape\' must be > 0: %s' %

image_shape)

if not image_shape.is_fully_defined():

return [check_ops.assert_positive(array_ops.shape(image),

["all dims of 'image.shape' "

"must be > 0."])]

else:

return []

def fix_image_flip_shape(image, result):

"""Set the shape to 3 dimensional if we don't know anything else.

Args:

image: original image size

result: flipped or transformed image

Returns:

An image whose shape is at least None,None,None.

"""

image_shape = image.get_shape()

if image_shape == tensor_shape.unknown_shape():

result.set_shape([None, None, None])

else:

result.set_shape(image_shape)

return result

def random_flip_up_down(image, seed=None):

"""Randomly flips an image vertically (upside down).

With a 1 in 2 chance, outputs the contents of `image` flipped along the first

dimension, which is `height`. Otherwise output the image as-is.

Args:

image: A 3-D tensor of shape `[height, width, channels].`

seed: A Python integer. Used to create a random seed. See

@{tf.set_random_seed}

for behavior.

Returns:

A 3-D tensor of the same type and shape as `image`.

Raises:

ValueError: if the shape of `image` not supported.

"""

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed)

mirror_cond = math_ops.less(uniform_random, .5)

result = control_flow_ops.cond(mirror_cond,

lambda: array_ops.reverse(image, [0]),

lambda: image)

return fix_image_flip_shape(image, result)

def random_flip_left_right(image, seed=None):

"""Randomly flip an image horizontally (left to right).

With a 1 in 2 chance, outputs the contents of `image` flipped along the

second dimension, which is `width`. Otherwise output the image as-is.

Args:

image: A 3-D tensor of shape `[height, width, channels].`

seed: A Python integer. Used to create a random seed. See

@{tf.set_random_seed}

for behavior.

Returns:

A 3-D tensor of the same type and shape as `image`.

Raises:

ValueError: if the shape of `image` not supported.

"""

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

uniform_random = random_ops.random_uniform([], 0, 1.0, seed=seed)

mirror_cond = math_ops.less(uniform_random, .5)

result = control_flow_ops.cond(mirror_cond,

lambda: array_ops.reverse(image, [1]),

lambda: image)

return fix_image_flip_shape(image, result)

def flip_left_right(image):

"""Flip an image horizontally (left to right).

Outputs the contents of `image` flipped along the second dimension, which is

`width`.

See also `reverse()`.

Args:

image: A 3-D tensor of shape `[height, width, channels].`

Returns:

A 3-D tensor of the same type and shape as `image`.

Raises:

ValueError: if the shape of `image` not supported.

"""

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

return fix_image_flip_shape(image, array_ops.reverse(image, [1]))

def flip_up_down(image):

"""Flip an image vertically (upside down).

Outputs the contents of `image` flipped along the first dimension, which is

`height`.

See also `reverse()`.

Args:

image: A 3-D tensor of shape `[height, width, channels].`

Returns:

A 3-D tensor of the same type and shape as `image`.

Raises:

ValueError: if the shape of `image` not supported.

"""

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

return fix_image_flip_shape(image, array_ops.reverse(image, [0]))

def rot90(image, k=1, name=None):

"""Rotate an image counter-clockwise by 90 degrees.

Args:

image: A 3-D tensor of shape `[height, width, channels]`.

k: A scalar integer. The number of times the image is rotated by 90 degrees.

name: A name for this operation (optional).

Returns:

A rotated 3-D tensor of the same type and shape as `image`.

"""

with ops.name_scope(name, 'rot90', [image, k]) as scope:

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

k = ops.convert_to_tensor(k, dtype=dtypes.int32, name='k')

k.get_shape().assert_has_rank(0)

k = math_ops.mod(k, 4)

def _rot90():

return array_ops.transpose(array_ops.reverse_v2(image, [1]),

[1, 0, 2])

def _rot180():

return array_ops.reverse_v2(image, [0, 1])

def _rot270():

return array_ops.reverse_v2(array_ops.transpose(image, [1, 0, 2]),

[1])

cases = [(math_ops.equal(k, 1), _rot90),

(math_ops.equal(k, 2), _rot180),

(math_ops.equal(k, 3), _rot270)]

ret = control_flow_ops.case(cases, default=lambda: image, exclusive=True,

name=scope)

ret.set_shape([None, None, image.get_shape()[2]])

return ret

def transpose_image(image):

"""Transpose an image by swapping the first and second dimension.

See also `transpose()`.

Args:

image: 3-D tensor of shape `[height, width, channels]`

Returns:

A 3-D tensor of shape `[width, height, channels]`

Raises:

ValueError: if the shape of `image` not supported.

"""

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

return array_ops.transpose(image, [1, 0, 2], name='transpose_image')

def central_crop(image, central_fraction):

"""Crop the central region of the image.

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:

image: 3-D float Tensor of shape [height, width, depth]

central_fraction: float (0, 1], fraction of size to crop

Raises:

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

Returns:

3-D float Tensor

"""

image = ops.convert_to_tensor(image, name='image')

if central_fraction <= 0.0 or central_fraction > 1.0:

raise ValueError('central_fraction must be within (0, 1]')

if central_fraction == 1.0:

return image

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

img_shape = array_ops.shape(image)

depth = image.get_shape()[2]

img_h = math_ops.to_double(img_shape[0])

img_w = math_ops.to_double(img_shape[1])

bbox_h_start = math_ops.to_int32((img_h - img_h * central_fraction) / 2)

bbox_w_start = math_ops.to_int32((img_w - img_w * central_fraction) / 2)

bbox_h_size = img_shape[0] - bbox_h_start * 2

bbox_w_size = img_shape[1] - bbox_w_start * 2

bbox_begin = array_ops.stack([bbox_h_start, bbox_w_start, 0])

bbox_size = array_ops.stack([bbox_h_size, bbox_w_size, -1])

image = array_ops.slice(image, bbox_begin, bbox_size)

# The first two dimensions are dynamic and unknown.

image.set_shape([None, None, depth])

return image

def pad_to_bounding_box(image, offset_height, offset_width, target_height,

target_width):

"""Pad `image` with zeros to the specified `height` and `width`.

Adds `offset_height` rows of zeros on top, `offset_width` columns of

zeros on the left, and then pads the image on the bottom and right

with zeros until it has dimensions `target_height`, `target_width`.

This op does nothing if `offset_*` is zero and the image already has size

`target_height` by `target_width`.

Args:

image: 4-D Tensor of shape `[batch, height, width, channels]` or

3-D Tensor of shape `[height, width, channels]`.

offset_height: Number of rows of zeros to add on top.

offset_width: Number of columns of zeros to add on the left.

target_height: Height of output image.

target_width: Width of output image.

Returns:

If `image` was 4-D, a 4-D float Tensor of shape

`[batch, target_height, target_width, channels]`

If `image` was 3-D, a 3-D float Tensor of shape

`[target_height, target_width, channels]`

Raises:

ValueError: If the shape of `image` is incompatible with the `offset_*` or

`target_*` arguments, or either `offset_height` or `offset_width` is

negative.

"""

image = ops.convert_to_tensor(image, name='image')

is_batch = True

image_shape = image.get_shape()

if image_shape.ndims == 3:

is_batch = False

image = array_ops.expand_dims(image, 0)

elif image_shape.ndims is None:

is_batch = False

image = array_ops.expand_dims(image, 0)

image.set_shape([None] * 4)

elif image_shape.ndims != 4:

raise ValueError('\'image\' must have either 3 or 4 dimensions.')

assert_ops = _CheckAtLeast3DImage(image, require_static=False)

batch, height, width, depth = _ImageDimensions(image, rank=4)

after_padding_width = target_width - offset_width - width

after_padding_height = target_height - offset_height - height

assert_ops += _assert(offset_height >= 0, ValueError,

'offset_height must be >= 0')

assert_ops += _assert(offset_width >= 0, ValueError,

'offset_width must be >= 0')

assert_ops += _assert(after_padding_width >= 0, ValueError,

'width must be <= target - offset')

assert_ops += _assert(after_padding_height >= 0, ValueError,

'height must be <= target - offset')

image = control_flow_ops.with_dependencies(assert_ops, image)

# Do not pad on the depth dimensions.

paddings = array_ops.reshape(

array_ops.stack([

0, 0, offset_height, after_padding_height, offset_width,

after_padding_width, 0, 0

]), [4, 2])

padded = array_ops.pad(image, paddings)

padded_shape = [None if _is_tensor(i) else i

for i in [batch, target_height, target_width, depth]]

padded.set_shape(padded_shape)

if not is_batch:

padded = array_ops.squeeze(padded, squeeze_dims=[0])

return padded

def crop_to_bounding_box(image, offset_height, offset_width, target_height,

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

Args:

image: 4-D Tensor of shape `[batch, height, width, channels]` or

3-D Tensor of shape `[height, width, channels]`.

offset_height: Vertical coordinate of the top-left corner of the result in

the input.

offset_width: Horizontal coordinate of the top-left corner of the result in

the input.

target_height: Height of the result.

target_width: Width of the result.

Returns:

If `image` was 4-D, a 4-D float Tensor of shape

`[batch, target_height, target_width, channels]`

If `image` was 3-D, a 3-D float Tensor of shape

`[target_height, target_width, channels]`

Raises:

ValueError: If the shape of `image` is incompatible with the `offset_*` or

`target_*` arguments, or either `offset_height` or `offset_width` is

negative, or either `target_height` or `target_width` is not positive.

"""

image = ops.convert_to_tensor(image, name='image')

is_batch = True

image_shape = image.get_shape()

if image_shape.ndims == 3:

is_batch = False

image = array_ops.expand_dims(image, 0)

elif image_shape.ndims is None:

is_batch = False

image = array_ops.expand_dims(image, 0)

image.set_shape([None] * 4)

elif image_shape.ndims != 4:

raise ValueError('\'image\' must have either 3 or 4 dimensions.')

assert_ops = _CheckAtLeast3DImage(image, require_static=False)

batch, height, width, depth = _ImageDimensions(image, rank=4)

assert_ops += _assert(offset_width >= 0, ValueError,

'offset_width must be >= 0.')

assert_ops += _assert(offset_height >= 0, ValueError,

'offset_height must be >= 0.')

assert_ops += _assert(target_width > 0, ValueError,

'target_width must be > 0.')

assert_ops += _assert(target_height > 0, ValueError,

'target_height must be > 0.')

assert_ops += _assert(width >= (target_width + offset_width), ValueError,

'width must be >= target + offset.')

assert_ops += _assert(height >= (target_height + offset_height), ValueError,

'height must be >= target + offset.')

image = control_flow_ops.with_dependencies(assert_ops, image)

cropped = array_ops.slice(

image,

array_ops.stack([0, offset_height, offset_width, 0]),

array_ops.stack([-1, target_height, target_width, -1]))

cropped_shape = [None if _is_tensor(i) else i

for i in [batch, target_height, target_width, depth]]

cropped.set_shape(cropped_shape)

if not is_batch:

cropped = array_ops.squeeze(cropped, squeeze_dims=[0])

return cropped

def resize_image_with_crop_or_pad(image, target_height, target_width):

"""Crops and/or pads an image to a target width and height.

Resizes an image to a target width and height by either centrally

cropping the image or padding it evenly with zeros.

If `width` or `height` is greater than the specified `target_width` or

`target_height` respectively, this op centrally crops along that dimension.

If `width` or `height` is smaller than the specified `target_width` or

`target_height` respectively, this op centrally pads with 0 along that

dimension.

Args:

image: 4-D Tensor of shape `[batch, height, width, channels]` or

3-D Tensor of shape `[height, width, channels]`.

target_height: Target height.

target_width: Target width.

Raises:

ValueError: if `target_height` or `target_width` are zero or negative.

Returns:

Cropped and/or padded image.

If `images` was 4-D, a 4-D float Tensor of shape

`[batch, new_height, new_width, channels]`.

If `images` was 3-D, a 3-D float Tensor of shape

`[new_height, new_width, channels]`.

"""

image = ops.convert_to_tensor(image, name='image')

image_shape = image.get_shape()

is_batch = True

if image_shape.ndims == 3:

is_batch = False

image = array_ops.expand_dims(image, 0)

elif image_shape.ndims is None:

is_batch = False

image = array_ops.expand_dims(image, 0)

image.set_shape([None] * 4)

elif image_shape.ndims != 4:

raise ValueError('\'image\' must have either 3 or 4 dimensions.')

assert_ops = _CheckAtLeast3DImage(image, require_static=False)

assert_ops += _assert(target_width > 0, ValueError,

'target_width must be > 0.')

assert_ops += _assert(target_height > 0, ValueError,

'target_height must be > 0.')

image = control_flow_ops.with_dependencies(assert_ops, image)

# `crop_to_bounding_box` and `pad_to_bounding_box` have their own checks.

# Make sure our checks come first, so that error messages are clearer.

if _is_tensor(target_height):

target_height = control_flow_ops.with_dependencies(

assert_ops, target_height)

if _is_tensor(target_width):

target_width = control_flow_ops.with_dependencies(assert_ops, target_width)

def max_(x, y):

if _is_tensor(x) or _is_tensor(y):

return math_ops.maximum(x, y)

else:

return max(x, y)

def min_(x, y):

if _is_tensor(x) or _is_tensor(y):

return math_ops.minimum(x, y)

else:

return min(x, y)

def equal_(x, y):

if _is_tensor(x) or _is_tensor(y):

return math_ops.equal(x, y)

else:

return x == y

_, height, width, _ = _ImageDimensions(image, rank=4)

width_diff = target_width - width

offset_crop_width = max_(-width_diff // 2, 0)

offset_pad_width = max_(width_diff // 2, 0)

height_diff = target_height - height

offset_crop_height = max_(-height_diff // 2, 0)

offset_pad_height = max_(height_diff // 2, 0)

# Maybe crop if needed.

cropped = crop_to_bounding_box(image, offset_crop_height, offset_crop_width,

min_(target_height, height),

min_(target_width, width))

# Maybe pad if needed.

resized = pad_to_bounding_box(cropped, offset_pad_height, offset_pad_width,

target_height, target_width)

# In theory all the checks below are redundant.

if resized.get_shape().ndims is None:

raise ValueError('resized contains no shape.')

_, resized_height, resized_width, _ = _ImageDimensions(resized, rank=4)

assert_ops = []

assert_ops += _assert(equal_(resized_height, target_height), ValueError,

'resized height is not correct.')

assert_ops += _assert(equal_(resized_width, target_width), ValueError,

'resized width is not correct.')

resized = control_flow_ops.with_dependencies(assert_ops, resized)

if not is_batch:

resized = array_ops.squeeze(resized, squeeze_dims=[0])

return resized

class ResizeMethod(object):

BILINEAR = 0

NEAREST_NEIGHBOR = 1

BICUBIC = 2

AREA = 3

def resize_images(images,

size,

method=ResizeMethod.BILINEAR,

align_corners=False):

"""Resize `images` to `size` using the specified `method`.

Resized images will be distorted if their original aspect ratio is not

the same as `size`. To avoid distortions see

@{tf.image.resize_image_with_crop_or_pad}.

`method` can be one of:

* <b>`ResizeMethod.BILINEAR`</b>: [Bilinear interpolation.](

https://en.wikipedia.org/wiki/Bilinear_interpolation)

* <b>`ResizeMethod.NEAREST_NEIGHBOR`</b>: [Nearest neighbor interpolation.](

https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation)

* <b>`ResizeMethod.BICUBIC`</b>: [Bicubic interpolation.](

https://en.wikipedia.org/wiki/Bicubic_interpolation)

* <b>`ResizeMethod.AREA`</b>: Area interpolation.

The return value has the same type as `images` if `method` is

`ResizeMethod.NEAREST_NEIGHBOR`. It will also have the same type as `images`

if the size of `images` can be statically determined to be the same as `size`,

because `images` is returned in this case. Otherwise, the return value has

type `float32`.

Args:

images: 4-D Tensor of shape `[batch, height, width, channels]` or

3-D Tensor of shape `[height, width, channels]`.

size: A 1-D int32 Tensor of 2 elements: `new_height, new_width`. The

new size for the images.

method: ResizeMethod. Defaults to `ResizeMethod.BILINEAR`.

align_corners: bool. If true, exactly align all 4 corners of the input and

output. Defaults to `false`.

Raises:

ValueError: if the shape of `images` is incompatible with the

shape arguments to this function

ValueError: if `size` has invalid shape or type.

ValueError: if an unsupported resize method is specified.

Returns:

If `images` was 4-D, a 4-D float Tensor of shape

`[batch, new_height, new_width, channels]`.

If `images` was 3-D, a 3-D float Tensor of shape

`[new_height, new_width, channels]`.

"""

images = ops.convert_to_tensor(images, name='images')

if images.get_shape().ndims is None:

raise ValueError('\'images\' contains no shape.')

# TODO(shlens): Migrate this functionality to the underlying Op's.

is_batch = True

if images.get_shape().ndims == 3:

is_batch = False

images = array_ops.expand_dims(images, 0)

elif images.get_shape().ndims != 4:

raise ValueError('\'images\' must have either 3 or 4 dimensions.')

_, height, width, _ = images.get_shape().as_list()

try:

size = ops.convert_to_tensor(size, dtypes.int32, name='size')

except (TypeError, ValueError):

raise ValueError('\'size\' must be a 1-D int32 Tensor')

if not size.get_shape().is_compatible_with([2]):

raise ValueError('\'size\' must be a 1-D Tensor of 2 elements: '

'new_height, new_width')

size_const_as_shape = tensor_util.constant_value_as_shape(size)

new_height_const = size_const_as_shape[0].value

new_width_const = size_const_as_shape[1].value

# If we can determine that the height and width will be unmodified by this

# transformation, we avoid performing the resize.

if all(x is not None

for x in [new_width_const, width, new_height_const, height]) and (

width == new_width_const and height == new_height_const):

if not is_batch:

images = array_ops.squeeze(images, squeeze_dims=[0])

return images

if method == ResizeMethod.BILINEAR:

images = gen_image_ops.resize_bilinear(images,

size,

align_corners=align_corners)

elif method == ResizeMethod.NEAREST_NEIGHBOR:

images = gen_image_ops.resize_nearest_neighbor(images,

size,

align_corners=align_corners)

elif method == ResizeMethod.BICUBIC:

images = gen_image_ops.resize_bicubic(images,

size,

align_corners=align_corners)

elif method == ResizeMethod.AREA:

images = gen_image_ops.resize_area(images,

size,

align_corners=align_corners)

else:

raise ValueError('Resize method is not implemented.')

# NOTE(mrry): The shape functions for the resize ops cannot unpack

# the packed values in `new_size`, so set the shape here.

images.set_shape([None, new_height_const, new_width_const, None])

if not is_batch:

images = array_ops.squeeze(images, squeeze_dims=[0])

return images

def per_image_standardization(image):

"""Linearly scales `image` to have zero mean and unit norm.

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:

image: 3-D tensor of shape `[height, width, channels]`.

Returns:

The standardized image with same shape as `image`.

Raises:

ValueError: if the shape of 'image' is incompatible with this function.

"""

image = ops.convert_to_tensor(image, name='image')

image = control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

num_pixels = math_ops.reduce_prod(array_ops.shape(image))

image = math_ops.cast(image, dtype=dtypes.float32)

image_mean = math_ops.reduce_mean(image)

variance = (math_ops.reduce_mean(math_ops.square(image)) -

math_ops.square(image_mean))

variance = gen_nn_ops.relu(variance)

stddev = math_ops.sqrt(variance)

# Apply a minimum normalization that protects us against uniform images.

min_stddev = math_ops.rsqrt(math_ops.cast(num_pixels, dtypes.float32))

pixel_value_scale = math_ops.maximum(stddev, min_stddev)

pixel_value_offset = image_mean

image = math_ops.subtract(image, pixel_value_offset)

image = math_ops.div(image, pixel_value_scale)

return image

def random_brightness(image, max_delta, seed=None):

"""Adjust the brightness of images by a random factor.

Equivalent to `adjust_brightness()` using a `delta` randomly picked in the

interval `[-max_delta, max_delta)`.

Args:

image: An image.

max_delta: float, must be non-negative.

seed: A Python integer. Used to create a random seed. See

@{tf.set_random_seed}

for behavior.

Returns:

The brightness-adjusted image.

Raises:

ValueError: if `max_delta` is negative.

"""

if max_delta < 0:

raise ValueError('max_delta must be non-negative.')

delta = random_ops.random_uniform([], -max_delta, max_delta, seed=seed)

return adjust_brightness(image, delta)

def random_contrast(image, lower, upper, seed=None):

"""Adjust the contrast of an image by a random factor.

Equivalent to `adjust_contrast()` but uses a `contrast_factor` randomly

picked in the interval `[lower, upper]`.

Args:

image: An image tensor with 3 or more dimensions.

lower: float. Lower bound for the random contrast factor.

upper: float. Upper bound for the random contrast factor.

seed: A Python integer. Used to create a random seed. See

@{tf.set_random_seed}

for behavior.

Returns:

The contrast-adjusted tensor.

Raises:

ValueError: if `upper <= lower` or if `lower < 0`.

"""

if upper <= lower:

raise ValueError('upper must be > lower.')

if lower < 0:

raise ValueError('lower must be non-negative.')

# Generate an a float in [lower, upper]

contrast_factor = random_ops.random_uniform([], lower, upper, seed=seed)

return adjust_contrast(image, contrast_factor)

def adjust_brightness(image, delta):

"""Adjust the brightness of RGB or Grayscale images.

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

Args:

image: A tensor.

delta: A scalar. Amount to add to the pixel values.

Returns:

A brightness-adjusted tensor of the same shape and type as `image`.

"""

with ops.name_scope(None, 'adjust_brightness', [image, delta]) as name:

image = ops.convert_to_tensor(image, name='image')

# Remember original dtype to so we can convert back if needed

orig_dtype = image.dtype

flt_image = convert_image_dtype(image, dtypes.float32)

adjusted = math_ops.add(flt_image,

math_ops.cast(delta, dtypes.float32),

name=name)

return convert_image_dtype(adjusted, orig_dtype, saturate=True)

def adjust_contrast(images, contrast_factor):

"""Adjust contrast of RGB or grayscale images.

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

Args:

images: Images to adjust. At least 3-D.

contrast_factor: A float multiplier for adjusting contrast.

Returns:

The contrast-adjusted image or images.

"""

with ops.name_scope(None, 'adjust_contrast',

[images, contrast_factor]) as name:

images = ops.convert_to_tensor(images, name='images')

# Remember original dtype to so we can convert back if needed

orig_dtype = images.dtype

flt_images = convert_image_dtype(images, dtypes.float32)

# pylint: disable=protected-access

adjusted = gen_image_ops._adjust_contrastv2(flt_images,

contrast_factor=contrast_factor,

name=name)

# pylint: enable=protected-access

return convert_image_dtype(adjusted, orig_dtype, saturate=True)

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

Args:

image : A Tensor.

gamma : A scalar. Non negative real number.

gain : A scalar. The constant multiplier.

Returns:

A Tensor. Gamma corrected output image.

Raises:

ValueError: If gamma is negative.

Notes:

For gamma greater than 1, the histogram will shift towards left and

the output image will be darker than the input image.

For gamma less than 1, the histogram will shift towards right and

the output image will be brighter than the input image.

References:

[1] http://en.wikipedia.org/wiki/Gamma_correction

"""