# 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 numpy as np

from tensorflow.python.compat import compat

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import ops

from tensorflow.python.framework import random_seed

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 control_flow_ops

from tensorflow.python.ops import gen_image_ops

from tensorflow.python.ops import math_ops

from tensorflow.python.ops import nn

from tensorflow.python.ops import nn_ops

from tensorflow.python.ops import random_ops

from tensorflow.python.ops import string_ops

from tensorflow.python.ops import variables

from tensorflow.python.util import deprecation

from tensorflow.python.util.tf_export import tf_export

ops.NotDifferentiable('RandomCrop')

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

ops.NotDifferentiable('NonMaxSuppressionWithOverlaps')

# pylint: disable=invalid-name

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 _Assert3DImage(image):

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

Performs the check statically if possible (i.e. if the shape

is statically known). Otherwise adds a control dependency

to an assert op that checks the dynamic shape.

Args:

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

Raises:

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

Returns:

If the shape of `image` could be verified statically, `image` is

returned unchanged, otherwise there will be a control dependency

added that asserts the correct dynamic shape.

"""

return control_flow_ops.with_dependencies(

_Check3DImage(image, require_static=False), image)

def _AssertAtLeast3DImage(image):

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

Performs the check statically if possible (i.e. if the shape

is statically known). Otherwise adds a control dependency

to an assert op that checks the dynamic shape.

Args:

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

Raises:

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

Returns:

If the shape of `image` could be verified statically, `image` is

returned unchanged, otherwise there will be a control dependency

added that asserts the correct dynamic shape.

"""

return control_flow_ops.with_dependencies(

_CheckAtLeast3DImage(image, require_static=False), image)

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.']),

check_ops.assert_greater_equal(

array_ops.rank(image),

3,

message="'image' must be at least three-dimensional.")

]

else:

return []

def _AssertGrayscaleImage(image):

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

Performs the check statically if possible (i.e. if the shape

is statically known). Otherwise adds a control dependency

to an assert op that checks the dynamic shape.

Args:

image: >= 2-D Tensor of size [*, 1]

Raises:

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

last dimension is not size 1.

Returns:

If the shape of `image` could be verified statically, `image` is

returned unchanged, otherwise there will be a control dependency

added that asserts the correct dynamic shape.

"""

return control_flow_ops.with_dependencies(

_CheckGrayscaleImage(image, require_static=False), image)

def _CheckGrayscaleImage(image, require_static=True):

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

Args:

image: >= 2-D Tensor of size [*, 1]

require_static: Boolean, whether static shape is required.

Raises:

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

last dimension is not size 1.

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

else:

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

except ValueError:

raise ValueError('A grayscale image must be at least two-dimensional.')

if require_static and not image_shape.is_fully_defined():

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

if image_shape.is_fully_defined():

if image_shape[-1] != 1:

raise ValueError('Last dimension of a grayscale image should be size 1.')

if not image_shape.is_fully_defined():

return [

check_ops.assert_equal(

array_ops.shape(image)[-1],

1,

message='Last dimension of a grayscale image should be size 1.'),

check_ops.assert_greater_equal(

array_ops.rank(image),

3,

message='A grayscale image must be at least two-dimensional.')

]

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

@tf_export('image.random_flip_up_down')

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: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor

of shape `[height, width, channels]`.

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

`tf.compat.v1.set_random_seed` for behavior.

Returns:

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

Raises:

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

"""

return _random_flip(image, 0, seed, 'random_flip_up_down')

@tf_export('image.random_flip_left_right')

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: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor

of shape `[height, width, channels]`.

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

`tf.compat.v1.set_random_seed` for behavior.

Returns:

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

Raises:

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

"""

return _random_flip(image, 1, seed, 'random_flip_left_right')

def _random_flip(image, flip_index, seed, scope_name):

"""Randomly (50% chance) flip an image along axis `flip_index`.

Args:

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

of shape `[height, width, channels]`.

flip_index: Dimension along which to flip image. Vertical: 0, Horizontal: 1

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

`tf.compat.v1.set_random_seed` for behavior.

scope_name: Name of the scope in which the ops are added.

Returns:

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

Raises:

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

"""

with ops.name_scope(None, scope_name, [image]) as scope:

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

image = _AssertAtLeast3DImage(image)

shape = image.get_shape()

if shape.ndims == 3 or shape.ndims is None:

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, [flip_index]),

lambda: image,

name=scope)

return fix_image_flip_shape(image, result)

elif shape.ndims == 4:

batch_size = array_ops.shape(image)[0]

uniform_random = random_ops.random_uniform([batch_size],

0,

1.0,

seed=seed)

flips = math_ops.round(

array_ops.reshape(uniform_random, [batch_size, 1, 1, 1]))

flips = math_ops.cast(flips, image.dtype)

flipped_input = array_ops.reverse(image, [flip_index + 1])

return flips * flipped_input + (1 - flips) * image

else:

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

@tf_export('image.flip_left_right')

def flip_left_right(image):

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

Outputs the contents of `image` flipped along the width dimension.

See also `reverse()`.

Args:

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

of shape `[height, width, channels]`.

Returns:

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

Raises:

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

"""

return _flip(image, 1, 'flip_left_right')

@tf_export('image.flip_up_down')

def flip_up_down(image):

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

Outputs the contents of `image` flipped along the height dimension.

See also `reverse()`.

Args:

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

of shape `[height, width, channels]`.

Returns:

A `Tensor` of the same type and shape as `image`.

Raises:

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

"""

return _flip(image, 0, 'flip_up_down')

def _flip(image, flip_index, scope_name):

"""Flip an image either horizontally or vertically.

Outputs the contents of `image` flipped along the dimension `flip_index`.

See also `reverse()`.

Args:

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

of shape `[height, width, channels]`.

flip_index: 0 For vertical, 1 for horizontal.

scope_name: string, scope name.

Returns:

A `Tensor` of the same type and shape as `image`.

Raises:

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

"""

with ops.name_scope(None, scope_name, [image]):

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

image = _AssertAtLeast3DImage(image)

shape = image.get_shape()

if shape.ndims == 3 or shape.ndims is None:

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

elif shape.ndims == 4:

return array_ops.reverse(image, [flip_index + 1])

else:

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

@tf_export('image.rot90')

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

"""Rotate image(s) counter-clockwise by 90 degrees.

For example:

```python

a=tf.constant([[[1],[2]],[[3],[4]]])

# rotating `a` counter clockwise by 90 degrees

a_rot=tf.image.rot90(a,k=1) #rotated `a`

print(a_rot) # [[[2],[4]],[[1],[3]]]

```

Args:

image: 4-D Tensor of shape `[batch, height, width, channels]` or 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 tensor of the same type and shape as `image`.

Raises:

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

"""

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

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

image = _AssertAtLeast3DImage(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)

shape = image.get_shape()

if shape.ndims == 3 or shape.ndims is None:

return _rot90_3D(image, k, scope)

elif shape.ndims == 4:

return _rot90_4D(image, k, scope)

else:

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

def _rot90_3D(image, k, name_scope):

"""Rotate image counter-clockwise by 90 degrees `k` times.

Args:

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

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

name_scope: A valid TensorFlow name scope.

Returns:

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

"""

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

result = control_flow_ops.case(

cases, default=lambda: image, exclusive=True, name=name_scope)

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

return result

def _rot90_4D(images, k, name_scope):

"""Rotate batch of images counter-clockwise by 90 degrees `k` times.

Args:

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

k: A scalar integer. The number of times the images are rotated by 90

degrees.

name_scope: A valid TensorFlow name scope.

Returns:

A 4-D `Tensor` of the same type and shape as `images`.

"""

def _rot90():

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

def _rot180():

return array_ops.reverse_v2(images, [1, 2])

def _rot270():

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

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

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

result = control_flow_ops.case(

cases, default=lambda: images, exclusive=True, name=name_scope)

shape = result.get_shape()

result.set_shape([shape[0], None, None, shape[3]])

return result

@tf_export('image.transpose', v1=['image.transpose', 'image.transpose_image'])

def transpose(image, name=None):

"""Transpose image(s) by swapping the height and width dimension.

Args:

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

of shape `[height, width, channels]`.

name: A name for this operation (optional).

Returns:

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

`[batch, width, height, channels]`

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

`[width, height, channels]`

Raises:

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

"""

with ops.name_scope(name, 'transpose', [image]):

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

image = _AssertAtLeast3DImage(image)

shape = image.get_shape()

if shape.ndims == 3 or shape.ndims is None:

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

elif shape.ndims == 4:

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

else:

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

@tf_export('image.central_crop')

def central_crop(image, 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.

--------

| |

| XXXX |

| XXXX |

| | where "X" is the central 50% of the image.

--------

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

Args:

image: Either a 3-D float Tensor of shape [height, width, depth], or a 4-D

Tensor of shape [batch_size, height, width, depth].

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

Raises:

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

Returns:

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

"""

with ops.name_scope(None, 'central_crop', [image]):

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

_AssertAtLeast3DImage(image)

rank = image.get_shape().ndims

if rank != 3 and rank != 4:

raise ValueError('`image` should either be a Tensor with rank = 3 or '

'rank = 4. Had rank = {}.'.format(rank))

# Helper method to return the `idx`-th dimension of `tensor`, along with

# a boolean signifying if the dimension is dynamic.

def _get_dim(tensor, idx):

static_shape = tensor.get_shape().dims[idx].value

if static_shape is not None:

return static_shape, False

return array_ops.shape(tensor)[idx], True

# Get the height, width, depth (and batch size, if the image is a 4-D

# tensor).

if rank == 3:

img_h, dynamic_h = _get_dim(image, 0)

img_w, dynamic_w = _get_dim(image, 1)

img_d = image.get_shape()[2]

else:

img_bs = image.get_shape()[0]

img_h, dynamic_h = _get_dim(image, 1)

img_w, dynamic_w = _get_dim(image, 2)

img_d = image.get_shape()[3]

# Compute the bounding boxes for the crop. The type and value of the

# bounding boxes depend on the `image` tensor's rank and whether / not the

# dimensions are statically defined.

if dynamic_h:

img_hd = math_ops.cast(img_h, dtypes.float64)

bbox_h_start = math_ops.cast((img_hd - img_hd * central_fraction) / 2,

dtypes.int32)

else:

img_hd = float(img_h)

bbox_h_start = int((img_hd - img_hd * central_fraction) / 2)

if dynamic_w:

img_wd = math_ops.cast(img_w, dtypes.float64)

bbox_w_start = math_ops.cast((img_wd - img_wd * central_fraction) / 2,

dtypes.int32)

else:

img_wd = float(img_w)

bbox_w_start = int((img_wd - img_wd * central_fraction) / 2)

bbox_h_size = img_h - bbox_h_start * 2

bbox_w_size = img_w - bbox_w_start * 2

if rank == 3:

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

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

else:

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

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

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

# Reshape the `image` tensor to the desired size.

if rank == 3:

image.set_shape([

None if dynamic_h else bbox_h_size,

None if dynamic_w else bbox_w_size, img_d

])

else:

image.set_shape([

img_bs, None if dynamic_h else bbox_h_size,

None if dynamic_w else bbox_w_size, img_d

])

return image

@tf_export('image.pad_to_bounding_box')

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.

"""

with ops.name_scope(None, 'pad_to_bounding_box', [image]):

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, axis=[0])

return padded

@tf_export('image.crop_to_bounding_box')

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.

"""

with ops.name_scope(None, 'crop_to_bounding_box', [image]):

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, axis=[0])

return cropped

@tf_export(

'image.resize_with_crop_or_pad',

v1=['image.resize_with_crop_or_pad', 'image.resize_image_with_crop_or_pad'])

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

"""

with ops.name_scope(None, 'resize_image_with_crop_or_pad', [image]):

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)