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

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 three-dimensional.')

if not all(x > 0 for x in image.get_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)

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)

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)

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

_Check3DImage(image)

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

_Check3DImage(image)

target_width):

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

_Check3DImage(image)

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)

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)

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

"""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:

return images

if method == ResizeMethod.BILINEAR:

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

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.reshape(images, [new_height, new_width, depth])

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

_Check3DImage(image)

height, width, depth = _ImageDimensions(image)

num_pixels = height * width * depth

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

stddev = math_ops.sqrt(variance)

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

min_stddev = constant_op.constant(1.0 / math.sqrt(num_pixels))

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.

_Check3DImage(image)

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 contrase of an image by a random factor.

_Check3DImage(image)

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.

if min_value is None:

min_value = image.dtype.min

if max_value is None:

max_value = image.dtype.max

with ops.op_scope([image, delta, min_value, max_value], None,

'adjust_brightness') as name:

adjusted = math_ops.add(

math_ops.cast(image, dtypes.float32),

math_ops.cast(delta, dtypes.float32),

name=name)

if image.dtype.is_integer:

rounded = math_ops.round(adjusted)

else:

rounded = adjusted

clipped = clip_ops.clip_by_value(rounded, float(min_value),

float(max_value))

output = math_ops.cast(clipped, image.dtype)

"""Adjust contrast of RGB or grayscale images.

_CheckAtLeast3DImage(images)

# If these are None, the min/max should be a nop, but still prevent overflows

# from the cast back to images.dtype at the end of adjust_contrast.

if min_value is None:

min_value = images.dtype.min

if max_value is None:

max_value = images.dtype.max

with ops.op_scope(

[images, contrast_factor, min_value,

max_value], None, 'adjust_contrast') as name:

adjusted = gen_image_ops.adjust_contrast(images,

contrast_factor=contrast_factor,

min_value=min_value,

max_value=max_value,

name=name)

if images.dtype.is_integer:

return math_ops.cast(math_ops.round(adjusted), images.dtype)

else:

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

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

size = tensor_util.ConstantValue(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.ConstantValue(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,