"""Returns the dimensions of an image tensor.

# A simple abstraction to provide names for each dimension. This abstraction

# should make it simpler to switch dimensions in the future (e.g. if we ever

# want to switch height and width.)

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

try:

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

except ValueError:

raise ValueError('\'image\' must be 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' %

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

if not image.get_shape().is_fully_defined():

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

if image.get_shape().ndims < 3:

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

if not all(x > 0 for x in image.get_shape()):

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

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

_Check3DImage(image, require_static=False)

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

mirror = math_ops.less(array_ops.pack([uniform_random, 1.0, 1.0]), 0.5)

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

_Check3DImage(image, require_static=False)

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

mirror = math_ops.less(array_ops.pack([1.0, uniform_random, 1.0]), 0.5)

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

_Check3DImage(image, require_static=False)

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

_Check3DImage(image, require_static=False)

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

_Check3DImage(image, require_static=False)

target_width):

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

_Check3DImage(image, require_static=True)

height, width, depth = _ImageDimensions(image)

if target_width < width:

raise ValueError('target_width must be >= width')

if target_height < height:

raise ValueError('target_height must be >= height')

after_padding_width = target_width - offset_width - width

after_padding_height = target_height - offset_height - height

if after_padding_width < 0:

raise ValueError('target_width not possible given '

'offset_width and image width')

if after_padding_height < 0:

raise ValueError('target_height not possible given '

'offset_height and image height')

# Do not pad on the depth dimensions.

if (offset_width or offset_height or after_padding_width or

after_padding_height):

paddings = [[offset_height, after_padding_height],

[offset_width, after_padding_width], [0, 0]]

padded = array_ops.pad(image, paddings)

padded.set_shape([target_height, target_width, depth])

else:

padded = image

target_width):

"""Crops an image to a specified bounding box.

_Check3DImage(image, require_static=True)

height, width, _ = _ImageDimensions(image)

if offset_width < 0:

raise ValueError('offset_width must be >= 0.')

if offset_height < 0:

raise ValueError('offset_height must be >= 0.')

if width < (target_width + offset_width):

raise ValueError('width must be >= target + offset.')

if height < (target_height + offset_height):

raise ValueError('height must be >= target + offset.')

cropped = array_ops.slice(image, [offset_height, offset_width, 0],

[target_height, target_width, -1])

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

_Check3DImage(image, require_static=True)

original_height, original_width, _ = _ImageDimensions(image)

if target_width <= 0:

raise ValueError('target_width must be > 0.')

if target_height <= 0:

raise ValueError('target_height must be > 0.')

offset_crop_width = 0

offset_pad_width = 0

if target_width < original_width:

offset_crop_width = (original_width - target_width) // 2

elif target_width > original_width:

offset_pad_width = (target_width - original_width) // 2

offset_crop_height = 0

offset_pad_height = 0

if target_height < original_height:

offset_crop_height = (original_height - target_height) // 2

elif target_height > original_height:

offset_pad_height = (target_height - original_height) // 2

# Maybe crop if needed.

cropped = crop_to_bounding_box(image, offset_crop_height, offset_crop_width,

min(target_height, original_height),

min(target_width, original_width))

# Maybe pad if needed.

resized = pad_to_bounding_box(cropped, offset_pad_height, offset_pad_width,

target_height, target_width)

if resized.get_shape().ndims is None:

raise ValueError('resized contains no shape.')

if not resized.get_shape()[0].is_compatible_with(target_height):

raise ValueError('resized height is not correct.')

if not resized.get_shape()[1].is_compatible_with(target_width):

raise ValueError('resized width is not correct.')

BILINEAR = 0

NEAREST_NEIGHBOR = 1

BICUBIC = 2

new_height,

new_width,

method=ResizeMethod.BILINEAR,

align_corners=False):

"""Resize `images` to `new_width`, `new_height` using the specified `method`.

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 len(images.get_shape()) == 3:

is_batch = False

images = array_ops.expand_dims(images, 0)

_, height, width, depth = _ImageDimensions(images)

if width == new_width and height == new_height:

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,

[new_height, new_width],

align_corners=align_corners)

elif method == ResizeMethod.NEAREST_NEIGHBOR:

images = gen_image_ops.resize_nearest_neighbor(images, [new_height,

new_width])

elif method == ResizeMethod.BICUBIC:

images = gen_image_ops.resize_bicubic(images, [new_height, new_width])

elif method == ResizeMethod.AREA:

images = gen_image_ops.resize_area(images, [new_height, new_width])

else:

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

if not is_batch:

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

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

_Check3DImage(image, require_static=False)

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

math_ops.sqrt(math_ops.cast(num_pixels, dtypes.float32)))

pixel_value_scale = math_ops.maximum(stddev, min_stddev)

pixel_value_offset = image_mean

image = math_ops.sub(image, pixel_value_offset)

image = math_ops.div(image, pixel_value_scale)

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

if max_delta < 0:

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

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

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

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)

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

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

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

"""Adjust contrast of RGB or grayscale images.

with ops.op_scope([images, contrast_factor], None, 'adjust_contrast') as name:

# 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

"""Shape function for the resize_bilinear and resize_nearest_neighbor ops."""

input_shape = op.inputs[0].get_shape().with_rank(4)

size = tensor_util.constant_value(op.inputs[1])

if size is not None:

height = size[0]

width = size[1]

else:

height = None

width = None

return [tensor_shape.TensorShape(

"""Shape function for image decoding ops."""

unused_input_shape = op.inputs[0].get_shape().merge_with(

tensor_shape.scalar())

channels = op.get_attr('channels') or None

"""Shape function for the random_crop op."""

input_shape = op.inputs[0].get_shape().with_rank(3)

unused_size_shape = op.inputs[1].get_shape().merge_with(

tensor_shape.vector(2))

size = tensor_util.constant_value(op.inputs[1])

if size is not None:

height = size[0]

width = size[1]

else:

height = None

width = None

channels = input_shape[2]

"""Randomly crops `image` to size `[target_height, target_width]`.

seed1, seed2 = random_seed.get_seed(seed)

return gen_image_ops.random_crop(image, size, seed=seed1, seed2=seed2,

"""Performs a safe cast of image data to `dtype`.

clamped = image

# When casting to a type with smaller representable range, clamp.

# Note that this covers casting to unsigned types as well.

if image.dtype.min < dtype.min and image.dtype.max > dtype.max:

clamped = clip_ops.clip_by_value(clamped,

math_ops.cast(dtype.min, image.dtype),

math_ops.cast(dtype.max, image.dtype))

elif image.dtype.min < dtype.min:

clamped = math_ops.maximum(clamped, math_ops.cast(dtype.min, image.dtype))

elif image.dtype.max > dtype.max:

clamped = math_ops.minimum(clamped, math_ops.cast(dtype.max, image.dtype))

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

if dtype == image.dtype:

return image

with ops.op_scope([image], name, 'convert_image') as name:

# Both integer: use integer multiplication in the larger range

if image.dtype.is_integer and dtype.is_integer:

scale_in = image.dtype.max

scale_out = dtype.max

if scale_in > scale_out:

# Scaling down, scale first, then cast. The scaling factor will

# cause in.max to be mapped to above out.max but below out.max+1,

# so that the output is safely in the supported range.

scale = (scale_in + 1) // (scale_out + 1)

scaled = math_ops.div(image, scale)

if saturate:

return saturate_cast(scaled, dtype)

else:

return math_ops.cast(scaled, dtype)

else:

# Scaling up, cast first, then scale. The scale will not map in.max to

# out.max, but converting back and forth should result in no change.

if saturate:

cast = saturate_cast(scaled, dtype)

else:

cast = math_ops.cast(image, dtype)

scale = (scale_out + 1) // (scale_in + 1)

return math_ops.mul(cast, scale)

elif image.dtype.is_floating and dtype.is_floating:

# Both float: Just cast, no possible overflows in the allowed ranges.

# Note: We're ignoreing float overflows. If your image dynamic range

# exceeds float range you're on your own.

return math_ops.cast(image, dtype)

else:

if image.dtype.is_integer:

# Converting to float: first cast, then scale. No saturation possible.

cast = math_ops.cast(image, dtype)

scale = 1. / image.dtype.max

return math_ops.mul(cast, scale)

else:

# Converting from float: first scale, then cast

scale = dtype.max + 0.5 # avoid rounding problems in the cast

scaled = math_ops.mul(image, scale)

if saturate:

return saturate_cast(scaled, dtype)

else:

"""Converts one or more images from RGB to Grayscale.

with ops.op_scope([images], None, 'rgb_to_grayscale'):

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

orig_dtype = images.dtype

flt_image = convert_image_dtype(images, dtypes.float32)

# Reference for converting between RGB and grayscale.

# https://en.wikipedia.org/wiki/Luma_%28video%29

rgb_weights = [0.2989, 0.5870, 0.1140]

rank_1 = array_ops.expand_dims(array_ops.rank(images) - 1, 0)

gray_float = math_ops.reduce_sum(flt_image * rgb_weights,

rank_1,

keep_dims=True)

gray_float.set_shape(images.get_shape()[:-1].concatenate([1]))

"""Converts one or more images from Grayscale to RGB.

with ops.op_scope([images], None, 'grayscale_to_rgb'):

rank_1 = array_ops.expand_dims(array_ops.rank(images) - 1, 0)

shape_list = (

[array_ops.ones(rank_1,

dtype=dtypes.int32)] + [array_ops.expand_dims(3, 0)])