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

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

"""Tests for tensorflow.ops.image_ops."""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import itertools

import math

import os

import numpy as np

from six.moves import xrange # pylint: disable=redefined-builtin

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import errors

from tensorflow.python.framework import ops

from tensorflow.python.framework import test_util

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import image_ops

from tensorflow.python.ops import io_ops

from tensorflow.python.platform import googletest

class RGBToHSVTest(test_util.TensorFlowTestCase):

def testBatch(self):

# Build an arbitrary RGB image

np.random.seed(7)

batch_size = 5

shape = (batch_size, 2, 7, 3)

for nptype in [np.float32, np.float64]:

inp = np.random.rand(*shape).astype(nptype)

# Convert to HSV and back, as a batch and individually

with self.test_session() as sess:

batch0 = constant_op.constant(inp)

batch1 = image_ops.rgb_to_hsv(batch0)

batch2 = image_ops.hsv_to_rgb(batch1)

split0 = array_ops.unpack(batch0)

split1 = list(map(image_ops.rgb_to_hsv, split0))

split2 = list(map(image_ops.hsv_to_rgb, split1))

join1 = array_ops.pack(split1)

join2 = array_ops.pack(split2)

batch1, batch2, join1, join2 = sess.run([batch1, batch2, join1, join2])

# Verify that processing batch elements together is the same as separate

self.assertAllClose(batch1, join1)

self.assertAllClose(batch2, join2)

self.assertAllClose(batch2, inp)

def testRGBToHSVRoundTrip(self):

data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

for nptype in [np.float32, np.float64]:

rgb_np = np.array(data, dtype=nptype).reshape([2, 2, 3]) / 255.

for use_gpu in [True, False]:

with self.test_session(use_gpu=use_gpu):

hsv = image_ops.rgb_to_hsv(rgb_np)

rgb = image_ops.hsv_to_rgb(hsv)

rgb_tf = rgb.eval()

self.assertAllClose(rgb_tf, rgb_np)

class GrayscaleToRGBTest(test_util.TensorFlowTestCase):

def _RGBToGrayscale(self, images):

is_batch = True

if len(images.shape) == 3:

is_batch = False

images = np.expand_dims(images, axis=0)

out_shape = images.shape[0:3] + (1,)

out = np.zeros(shape=out_shape, dtype=np.uint8)

for batch in xrange(images.shape[0]):

for y in xrange(images.shape[1]):

for x in xrange(images.shape[2]):

red = images[batch, y, x, 0]

green = images[batch, y, x, 1]

blue = images[batch, y, x, 2]

gray = 0.2989 * red + 0.5870 * green + 0.1140 * blue

out[batch, y, x, 0] = int(gray)

if not is_batch:

out = np.squeeze(out, axis=0)

return out

def _TestRGBToGrayscale(self, x_np):

y_np = self._RGBToGrayscale(x_np)

with self.test_session():

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.rgb_to_grayscale(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testBasicRGBToGrayscale(self):

# 4-D input with batch dimension.

x_np = np.array([[1, 2, 3], [4, 10, 1]],

dtype=np.uint8).reshape([1, 1, 2, 3])

self._TestRGBToGrayscale(x_np)

# 3-D input with no batch dimension.

x_np = np.array([[1, 2, 3], [4, 10, 1]], dtype=np.uint8).reshape([1, 2, 3])

self._TestRGBToGrayscale(x_np)

def testBasicGrayscaleToRGB(self):

# 4-D input with batch dimension.

x_np = np.array([[1, 2]], dtype=np.uint8).reshape([1, 1, 2, 1])

y_np = np.array([[1, 1, 1], [2, 2, 2]],

dtype=np.uint8).reshape([1, 1, 2, 3])

with self.test_session():

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.grayscale_to_rgb(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

# 3-D input with no batch dimension.

x_np = np.array([[1, 2]], dtype=np.uint8).reshape([1, 2, 1])

y_np = np.array([[1, 1, 1], [2, 2, 2]], dtype=np.uint8).reshape([1, 2, 3])

with self.test_session():

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.grayscale_to_rgb(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testShapeInference(self):

# Shape inference works and produces expected output where possible

rgb_shape = [7, None, 19, 3]

gray_shape = rgb_shape[:-1] + [1]

with self.test_session():

rgb_tf = array_ops.placeholder(dtypes.uint8, shape=rgb_shape)

gray = image_ops.rgb_to_grayscale(rgb_tf)

self.assertEqual(gray_shape, gray.get_shape().as_list())

with self.test_session():

gray_tf = array_ops.placeholder(dtypes.uint8, shape=gray_shape)

rgb = image_ops.grayscale_to_rgb(gray_tf)

self.assertEqual(rgb_shape, rgb.get_shape().as_list())

# Shape inference does not break for unknown shapes

with self.test_session():

rgb_tf_unknown = array_ops.placeholder(dtypes.uint8)

gray_unknown = image_ops.rgb_to_grayscale(rgb_tf_unknown)

self.assertFalse(gray_unknown.get_shape())

with self.test_session():

gray_tf_unknown = array_ops.placeholder(dtypes.uint8)

rgb_unknown = image_ops.grayscale_to_rgb(gray_tf_unknown)

self.assertFalse(rgb_unknown.get_shape())

class AdjustHueTest(test_util.TensorFlowTestCase):

def testAdjustNegativeHue(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

delta = -0.25

y_data = [0, 13, 1, 54, 226, 59, 8, 234, 150, 255, 39, 1]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_hue(x, delta)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testAdjustPositiveHue(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

delta = 0.25

y_data = [13, 0, 11, 226, 54, 221, 234, 8, 92, 1, 217, 255]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_hue(x, delta)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

class AdjustSaturationTest(test_util.TensorFlowTestCase):

def testHalfSaturation(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

saturation_factor = 0.5

y_data = [6, 9, 13, 140, 180, 226, 135, 121, 234, 172, 255, 128]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_saturation(x, saturation_factor)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testTwiceSaturation(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

saturation_factor = 2.0

y_data = [0, 5, 13, 0, 106, 226, 30, 0, 234, 89, 255, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.adjust_saturation(x, saturation_factor)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

class FlipTransposeRotateTest(test_util.TensorFlowTestCase):

def testIdempotentLeftRight(self):

x_np = np.array([[1, 2, 3], [1, 2, 3]], dtype=np.uint8).reshape([2, 3, 1])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_left_right(image_ops.flip_left_right(x_tf))

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

def testLeftRight(self):

x_np = np.array([[1, 2, 3], [1, 2, 3]], dtype=np.uint8).reshape([2, 3, 1])

y_np = np.array([[3, 2, 1], [3, 2, 1]], dtype=np.uint8).reshape([2, 3, 1])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_left_right(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testIdempotentUpDown(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_up_down(image_ops.flip_up_down(x_tf))

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

def testUpDown(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

y_np = np.array([[4, 5, 6], [1, 2, 3]], dtype=np.uint8).reshape([2, 3, 1])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.flip_up_down(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testIdempotentTranspose(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.transpose_image(image_ops.transpose_image(x_tf))

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

def testTranspose(self):

x_np = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8).reshape([2, 3, 1])

y_np = np.array([[1, 4], [2, 5], [3, 6]], dtype=np.uint8).reshape([3, 2, 1])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.transpose_image(x_tf)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testPartialShapes(self):

p_unknown_rank = array_ops.placeholder(dtypes.uint8)

p_unknown_dims = array_ops.placeholder(dtypes.uint8,

shape=[None, None, None])

p_unknown_width = array_ops.placeholder(dtypes.uint8, shape=[64, None, 3])

p_wrong_rank = array_ops.placeholder(dtypes.uint8, shape=[None, None])

p_zero_dim = array_ops.placeholder(dtypes.uint8, shape=[64, 0, 3])

for op in [image_ops.flip_left_right,

image_ops.flip_up_down,

image_ops.random_flip_left_right,

image_ops.random_flip_up_down,

image_ops.transpose_image,

image_ops.rot90]:

transformed_unknown_rank = op(p_unknown_rank)

self.assertEqual(3, transformed_unknown_rank.get_shape().ndims)

transformed_unknown_dims = op(p_unknown_dims)

self.assertEqual(3, transformed_unknown_dims.get_shape().ndims)

transformed_unknown_width = op(p_unknown_width)

self.assertEqual(3, transformed_unknown_width.get_shape().ndims)

with self.assertRaisesRegexp(ValueError, 'must be three-dimensional'):

op(p_wrong_rank)

with self.assertRaisesRegexp(ValueError, 'must be > 0'):

op(p_zero_dim)

def testRot90GroupOrder(self):

image = np.arange(24, dtype=np.uint8).reshape([2, 4, 3])

for use_gpu in [False, True]:

with self.test_session(use_gpu=use_gpu):

rotated = image

for _ in xrange(4):

rotated = image_ops.rot90(rotated)

self.assertAllEqual(image, rotated.eval())

def testRot90NumpyEquivalence(self):

image = np.arange(24, dtype=np.uint8).reshape([2, 4, 3])

for use_gpu, k in itertools.product([False, True], range(4)):

with self.test_session(use_gpu=use_gpu):

y_np = np.rot90(image, k=k)

y_tf = image_ops.rot90(image, k=k)

self.assertAllEqual(y_np, y_tf.eval())

class RandomFlipTest(test_util.TensorFlowTestCase):

def testRandomLeftRight(self):

x_np = np.array([0, 1], dtype=np.uint8).reshape([1, 2, 1])

num_iterations = 500

hist = [0, 0]

with self.test_session():

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.random_flip_left_right(x_tf)

for _ in xrange(num_iterations):

y_np = y.eval().flatten()[0]

hist[y_np] += 1

# Ensure that each entry is observed within 4 standard deviations.

four_stddev = 4.0 * np.sqrt(num_iterations / 2.0)

self.assertAllClose(hist, [num_iterations / 2.0] * 2, atol=four_stddev)

def testRandomUpDown(self):

x_np = np.array([0, 1], dtype=np.uint8).reshape([2, 1, 1])

num_iterations = 500

hist = [0, 0]

with self.test_session():

x_tf = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.random_flip_up_down(x_tf)

for _ in xrange(num_iterations):

y_np = y.eval().flatten()[0]

hist[y_np] += 1

# Ensure that each entry is observed within 4 standard deviations.

four_stddev = 4.0 * np.sqrt(num_iterations / 2.0)

self.assertAllClose(hist, [num_iterations / 2.0] * 2, atol=four_stddev)

class AdjustContrastTest(test_util.TensorFlowTestCase):

def _testContrast(self, x_np, y_np, contrast_factor):

for use_gpu in [True, False]:

with self.test_session(use_gpu=use_gpu):

x = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.adjust_contrast(x, contrast_factor)

y_tf = y.eval()

self.assertAllClose(y_tf, y_np, 1e-6)

def testDoubleContrastUint8(self):

x_shape = [1, 2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [0, 0, 0, 62, 169, 255, 28, 0, 255, 135, 255, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testContrast(x_np, y_np, contrast_factor=2.0)

def testDoubleContrastFloat(self):

x_shape = [1, 2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.float).reshape(x_shape) / 255.

y_data = [-45.25, -90.75, -92.5, 62.75, 169.25, 333.5, 28.75, -84.75, 349.5,

134.75, 409.25, -116.5]

y_np = np.array(y_data, dtype=np.float).reshape(x_shape) / 255.

self._testContrast(x_np, y_np, contrast_factor=2.0)

def testHalfContrastUint8(self):

x_shape = [1, 2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [22, 52, 65, 49, 118, 172, 41, 54, 176, 67, 178, 59]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testContrast(x_np, y_np, contrast_factor=0.5)

def testBatchDoubleContrast(self):

x_shape = [2, 1, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [0, 0, 0, 81, 200, 255, 10, 0, 255, 116, 255, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testContrast(x_np, y_np, contrast_factor=2.0)

class AdjustBrightnessTest(test_util.TensorFlowTestCase):

def _testBrightness(self, x_np, y_np, delta):

with self.test_session():

x = constant_op.constant(x_np, shape=x_np.shape)

y = image_ops.adjust_brightness(x, delta)

y_tf = y.eval()

self.assertAllClose(y_tf, y_np, 1e-6)

def testPositiveDeltaUint8(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [10, 15, 23, 64, 145, 236, 47, 18, 244, 100, 255, 11]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testBrightness(x_np, y_np, delta=10. / 255.)

def testPositiveDeltaFloat(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.float32).reshape(x_shape) / 255.

y_data = [10, 15, 23, 64, 145, 236, 47, 18, 244, 100, 265, 11]

y_np = np.array(y_data, dtype=np.float32).reshape(x_shape) / 255.

self._testBrightness(x_np, y_np, delta=10. / 255.)

def testNegativeDelta(self):

x_shape = [2, 2, 3]

x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]

x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape)

y_data = [0, 0, 3, 44, 125, 216, 27, 0, 224, 80, 245, 0]

y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape)

self._testBrightness(x_np, y_np, delta=-10. / 255.)

class PerImageWhiteningTest(test_util.TensorFlowTestCase):

def _NumpyPerImageWhitening(self, x):

num_pixels = np.prod(x.shape)

x2 = np.square(x).astype(np.float32)

mn = np.mean(x)

vr = np.mean(x2) - (mn * mn)

stddev = max(math.sqrt(vr), 1.0 / math.sqrt(num_pixels))

y = x.astype(np.float32)

y -= mn

y /= stddev

return y

def testBasic(self):

x_shape = [13, 9, 3]

x_np = np.arange(0, np.prod(x_shape), dtype=np.int32).reshape(x_shape)

y_np = self._NumpyPerImageWhitening(x_np)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.per_image_whitening(x)

y_tf = y.eval()

self.assertAllClose(y_tf, y_np, atol=1e-4)

def testUniformImage(self):

im_np = np.ones([19, 19, 3]).astype(np.float32) * 249

im = constant_op.constant(im_np)

whiten = image_ops.per_image_whitening(im)

with self.test_session():

whiten_np = whiten.eval()

self.assertFalse(np.any(np.isnan(whiten_np)))

class CropToBoundingBoxTest(test_util.TensorFlowTestCase):

def _CropToBoundingBox(self, x, offset_height, offset_width,

target_height, target_width, use_tensor_inputs):

if use_tensor_inputs:

offset_height = ops.convert_to_tensor(offset_height)

offset_width = ops.convert_to_tensor(offset_width)

target_height = ops.convert_to_tensor(target_height)

target_width = ops.convert_to_tensor(target_width)

x_tensor = array_ops.placeholder(x.dtype, shape=[None]*x.ndim)

feed_dict = {x_tensor: x}

else:

x_tensor = x

feed_dict = {}

y = image_ops.crop_to_bounding_box(x_tensor, offset_height, offset_width,

target_height, target_width)

if not use_tensor_inputs:

self.assertTrue(y.get_shape().is_fully_defined())

with self.test_session():

return y.eval(feed_dict=feed_dict)

def _assertReturns(self, x, x_shape, offset_height, offset_width,

y, y_shape, use_tensor_inputs_options=None):

use_tensor_inputs_options = use_tensor_inputs_options or [False, True]

target_height, target_width, _ = y_shape

x = np.array(x).reshape(x_shape)

y = np.array(y).reshape(y_shape)

for use_tensor_inputs in use_tensor_inputs_options:

y_tf = self._CropToBoundingBox(x, offset_height, offset_width,

target_height, target_width,

use_tensor_inputs)

self.assertAllClose(y, y_tf)

def _assertRaises(self, x, x_shape, offset_height, offset_width,

target_height, target_width, err_msg,

use_tensor_inputs_options=None):

use_tensor_inputs_options = use_tensor_inputs_options or [False, True]

x = np.array(x).reshape(x_shape)

for use_tensor_inputs in use_tensor_inputs_options:

try:

self._CropToBoundingBox(x, offset_height, offset_width,

target_height, target_width,

use_tensor_inputs)

except Exception as e:

if err_msg not in str(e):

raise

else:

raise AssertionError('Exception not raised: %s' % err_msg)

def testNoOp(self):

x_shape = [10, 10, 10]

x = np.random.uniform(size=x_shape)

self._assertReturns(x, x_shape, 0, 0, x, x_shape)

def testCrop(self):

x = [1, 2, 3,

4, 5, 6,

7, 8, 9]

x_shape = [3, 3, 1]

offset_height, offset_width = [1, 0]

y_shape = [2, 3, 1]

y = [4, 5, 6,

7, 8, 9]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 1]

y_shape = [3, 2, 1]

y = [2, 3,

5, 6,

8, 9]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 0]

y_shape = [2, 3, 1]

y = [1, 2, 3,

4, 5, 6]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 0]

y_shape = [3, 2, 1]

y = [1, 2,

4, 5,

7, 8]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

def testNon3DInput(self):

# Input image is not 3D

x = [0] * 15

offset_height, offset_width = [0, 0]

target_height, target_width = [2, 2]

for x_shape in ([1, 3, 5, 1], [3, 5]):

self._assertRaises(x, x_shape, offset_height, offset_width,

target_height, target_width,

"'image' must be three-dimensional")

def testZeroLengthInput(self):

# Input image has 0-length dimension(s).

# Each line is a test configuration:

# x_shape, target_height, target_width

test_config = (([0, 2, 2], 1, 1),

([2, 0, 2], 1, 1),

([2, 2, 0], 1, 1),

([0, 2, 2], 0, 1),

([2, 0, 2], 1, 0))

offset_height, offset_width = [0, 0]

x = []

for x_shape, target_height, target_width in test_config:

self._assertRaises(x, x_shape, offset_height, offset_width,

target_height, target_width,

"all dims of 'image.shape' must be > 0",

use_tensor_inputs_options=[False])

# Multiple assertion could fail, but the evaluation order is arbitrary.

# Match gainst generic pattern.

self._assertRaises(x, x_shape, offset_height, offset_width,

target_height, target_width,

"assertion failed:",

use_tensor_inputs_options=[True])

def testBadParams(self):

x_shape = [4, 4, 1]

x = np.zeros(x_shape)

# Each line is a test configuration:

# (offset_height, offset_width, target_height, target_width), err_msg

test_config = (([-1, 0, 3, 3], 'offset_height must be >= 0'),

([0, -1, 3, 3], 'offset_width must be >= 0'),

([0, 0, 0, 3], 'target_height must be > 0'),

([0, 0, 3, 0], 'target_width must be > 0'),

([2, 0, 3, 3], 'height must be >= target + offset'),

([0, 2, 3, 3], 'width must be >= target + offset'))

for params, err_msg in test_config:

self._assertRaises(x, x_shape, *params, err_msg=err_msg)

class CentralCropTest(test_util.TensorFlowTestCase):

def testNoOp(self):

x_shape = [13, 9, 3]

x_np = np.ones(x_shape, dtype=np.float32)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.central_crop(x, 1.0)

y_tf = y.eval()

self.assertAllEqual(y_tf, x_np)

self.assertEqual(y.op.name, x.op.name)

def testCropping(self):

x_shape = [4, 8, 1]

x_np = np.array([[1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7, 8],

[1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7, 8]],

dtype=np.int32).reshape(x_shape)

y_np = np.array([[3, 4, 5, 6], [3, 4, 5, 6]]).reshape([2, 4, 1])

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

y = image_ops.central_crop(x, 0.5)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testError(self):

x_shape = [13, 9, 3]

x_np = np.ones(x_shape, dtype=np.float32)

with self.test_session():

x = constant_op.constant(x_np, shape=x_shape)

with self.assertRaises(ValueError):

_ = image_ops.central_crop(x, 0.0)

with self.assertRaises(ValueError):

_ = image_ops.central_crop(x, 1.01)

class PadToBoundingBoxTest(test_util.TensorFlowTestCase):

def _PadToBoundingBox(self, x, offset_height, offset_width,

target_height, target_width, use_tensor_inputs):

if use_tensor_inputs:

offset_height = ops.convert_to_tensor(offset_height)

offset_width = ops.convert_to_tensor(offset_width)

target_height = ops.convert_to_tensor(target_height)

target_width = ops.convert_to_tensor(target_width)

x_tensor = array_ops.placeholder(x.dtype, shape=[None]*x.ndim)

feed_dict = {x_tensor: x}

else:

x_tensor = x

feed_dict = {}

y = image_ops.pad_to_bounding_box(x_tensor, offset_height, offset_width,

target_height, target_width)

if not use_tensor_inputs:

self.assertTrue(y.get_shape().is_fully_defined())

with self.test_session():

return y.eval(feed_dict=feed_dict)

def _assertReturns(self, x, x_shape, offset_height, offset_width,

y, y_shape, use_tensor_inputs_options=None):

use_tensor_inputs_options = use_tensor_inputs_options or [False, True]

target_height, target_width, _ = y_shape

x = np.array(x).reshape(x_shape)

y = np.array(y).reshape(y_shape)

for use_tensor_inputs in use_tensor_inputs_options:

y_tf = self._PadToBoundingBox(x, offset_height, offset_width,

target_height, target_width,

use_tensor_inputs)

self.assertAllClose(y, y_tf)

def _assertRaises(self, x, x_shape, offset_height, offset_width,

target_height, target_width, err_msg,

use_tensor_inputs_options=None):

use_tensor_inputs_options = use_tensor_inputs_options or [False, True]

x = np.array(x).reshape(x_shape)

for use_tensor_inputs in use_tensor_inputs_options:

try:

self._PadToBoundingBox(x, offset_height, offset_width,

target_height, target_width,

use_tensor_inputs)

except Exception as e:

if err_msg not in str(e):

raise

else:

raise AssertionError('Exception not raised: %s' % err_msg)

def testNoOp(self):

x_shape = [10, 10, 10]

x = np.random.uniform(size=x_shape)

offset_height, offset_width = [0, 0]

self._assertReturns(x, x_shape, offset_height, offset_width, x, x_shape)

def testPadding(self):

x = [1, 2, 3,

4, 5, 6,

7, 8, 9]

x_shape = [3, 3, 1]

offset_height, offset_width = [1, 0]

y = [0, 0, 0,

1, 2, 3,

4, 5, 6,

7, 8, 9]

y_shape = [4, 3, 1]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 1]

y = [0, 1, 2, 3,

0, 4, 5, 6,

0, 7, 8, 9]

y_shape = [3, 4, 1]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 0]

y = [1, 2, 3,

4, 5, 6,

7, 8, 9,

0, 0, 0]

y_shape = [4, 3, 1]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

offset_height, offset_width = [0, 0]

y = [1, 2, 3, 0,

4, 5, 6, 0,

7, 8, 9, 0]

y_shape = [3, 4, 1]

self._assertReturns(x, x_shape, offset_height, offset_width, y, y_shape)

def testNon3DInput(self):

# Input image is not 3D

x = [0] * 15

offset_height, offset_width = [0, 0]

target_height, target_width = [2, 2]

for x_shape in ([1, 3, 5, 1], [3, 5]):

self._assertRaises(x, x_shape, offset_height, offset_width,

target_height, target_width,

"'image' must be three-dimensional")

def testZeroLengthInput(self):

# Input image has 0-length dimension(s).

# Each line is a test configuration:

# x_shape, target_height, target_width

test_config = (([0, 2, 2], 2, 2),

([2, 0, 2], 2, 2),

([2, 2, 0], 2, 2))

offset_height, offset_width = [0, 0]

x = []

for x_shape, target_height, target_width in test_config:

self._assertRaises(x, x_shape, offset_height, offset_width,

target_height, target_width,

"all dims of 'image.shape' must be > 0",

use_tensor_inputs_options=[False])

# The orignal error message does not contain back slashes. However, they

# are added by either the assert op or the runtime. If this behaviour

# changes in the future, the match string will also needs to be changed.

self._assertRaises(x, x_shape, offset_height, offset_width,

target_height, target_width,

"all dims of \\'image.shape\\' must be > 0",

use_tensor_inputs_options=[True])

def testBadParams(self):

x_shape = [3, 3, 1]

x = np.zeros(x_shape)

# Each line is a test configuration:

# offset_height, offset_width, target_height, target_width, err_msg

test_config = ((-1, 0, 4, 4, 'offset_height must be >= 0'),

( 0,-1, 4, 4, 'offset_width must be >= 0'),

( 2, 0, 4, 4, 'height must be <= target - offset'),

( 0, 2, 4, 4, 'width must be <= target - offset'))

for config_item in test_config:

self._assertRaises(x, x_shape, *config_item)

class SelectDistortedCropBoxTest(test_util.TensorFlowTestCase):

def _testSampleDistortedBoundingBox(self, image, bounding_box,

min_object_covered, aspect_ratio_range,

area_range):

original_area = float(np.prod(image.shape))

bounding_box_area = float((bounding_box[3] - bounding_box[1]) *

(bounding_box[2] - bounding_box[0]))

image_size_np = np.array(image.shape, dtype=np.int32)

bounding_box_np = (np.array(bounding_box, dtype=np.float32)

.reshape([1, 1, 4]))

aspect_ratios = []

area_ratios = []

fraction_object_covered = []

num_iter = 1000

with self.test_session():

image_tf = constant_op.constant(image,

shape=image.shape)

image_size_tf = constant_op.constant(image_size_np,

shape=image_size_np.shape)

bounding_box_tf = constant_op.constant(bounding_box_np,

dtype=dtypes.float32,

shape=bounding_box_np.shape)

begin, end, _ = image_ops.sample_distorted_bounding_box(

image_size=image_size_tf,

bounding_boxes=bounding_box_tf,

min_object_covered=min_object_covered,

aspect_ratio_range=aspect_ratio_range,

area_range=area_range)

y = array_ops.slice(image_tf, begin, end)

for _ in xrange(num_iter):

y_tf = y.eval()

crop_height = y_tf.shape[0]

crop_width = y_tf.shape[1]

aspect_ratio = float(crop_width) / float(crop_height)

area = float(crop_width * crop_height)

aspect_ratios.append(aspect_ratio)

area_ratios.append(area / original_area)

fraction_object_covered.append(float(np.sum(y_tf)) / bounding_box_area)

# Ensure that each entry is observed within 3 standard deviations.

# num_bins = 10

# aspect_ratio_hist, _ = np.histogram(aspect_ratios,

# bins=num_bins,

# range=aspect_ratio_range)

# mean = np.mean(aspect_ratio_hist)

# stddev = np.sqrt(mean)

# TODO(wicke, shlens, dga): Restore this test so that it is no longer flaky.

# TODO(irving): Since the rejection probability is not independent of the

# aspect ratio, the aspect_ratio random value is not exactly uniformly

# distributed in [min_aspect_ratio, max_aspect_ratio). This test should be

# fixed to reflect the true statistical property, then tightened to enforce

# a stricter bound. Or, ideally, the sample_distorted_bounding_box Op

# be fixed to not use rejection sampling and generate correctly uniform

# aspect ratios.

# self.assertAllClose(aspect_ratio_hist,

# [mean] * num_bins, atol=3.6 * stddev)

# The resulting crop will not be uniformly distributed in area. In practice,

# we find that the area skews towards the small sizes. Instead, we perform

# a weaker test to ensure that the area ratios are merely within the

# specified bounds.

self.assertLessEqual(max(area_ratios), area_range[1])

self.assertGreaterEqual(min(area_ratios), area_range[0])

# For reference, here is what the distribution of area ratios look like.

area_ratio_hist, _ = np.histogram(area_ratios, bins=10, range=area_range)

print('area_ratio_hist ', area_ratio_hist)

# Ensure that fraction_object_covered is satisfied.

# TODO(wicke, shlens, dga): Restore this test so that it is no longer flaky.

# self.assertGreaterEqual(min(fraction_object_covered), min_object_covered)

def testWholeImageBoundingBox(self):

height = 40

width = 50

image_size = [height, width, 1]

bounding_box = [0.0, 0.0, 1.0, 1.0]

image = np.arange(0, np.prod(image_size),

dtype=np.int32).reshape(image_size)

self._testSampleDistortedBoundingBox(image,

bounding_box,

min_object_covered=0.1,

aspect_ratio_range=(0.75, 1.33),

area_range=(0.05, 1.0))

def testWithBoundingBox(self):

height = 40

width = 50

x_shape = [height, width, 1]

image = np.zeros(x_shape, dtype=np.int32)

# Create an object with 1's in a region with area A and require that

# the total pixel values >= 0.1 * A.

min_object_covered = 0.1

xmin = 2

ymin = 3

xmax = 12

ymax = 13

for x in np.arange(xmin, xmax + 1, 1):

for y in np.arange(ymin, ymax + 1, 1):

image[x, y] = 1

# Bounding box is specified as (ymin, xmin, ymax, xmax) in

# relative coordinates.

bounding_box = (float(ymin) / height, float(xmin) / width,

float(ymax) / height, float(xmax) / width)

self._testSampleDistortedBoundingBox(image,

bounding_box=bounding_box,

min_object_covered=min_object_covered,

aspect_ratio_range=(0.75, 1.33),

area_range=(0.05, 1.0))

def testSampleDistortedBoundingBoxShape(self):

with self.test_session():

image_size = constant_op.constant([40, 50, 1],

shape=[3],

dtype=dtypes.int32)

bounding_box = constant_op.constant([0.0, 0.0, 1.0, 1.0],

shape=[4],

dtype=dtypes.float32,)

begin, end, bbox_for_drawing = image_ops.sample_distorted_bounding_box(

image_size=image_size,

bounding_boxes=bounding_box,

min_object_covered=0.1,

aspect_ratio_range=(0.75, 1.33),

area_range=(0.05, 1.0))

# Test that the shapes are correct.

self.assertAllEqual([3], begin.get_shape().as_list())

self.assertAllEqual([3], end.get_shape().as_list())

self.assertAllEqual([1, 1, 4], bbox_for_drawing.get_shape().as_list())

class ResizeImagesTest(test_util.TensorFlowTestCase):

OPTIONS = [image_ops.ResizeMethod.BILINEAR,

image_ops.ResizeMethod.NEAREST_NEIGHBOR,

image_ops.ResizeMethod.BICUBIC,

image_ops.ResizeMethod.AREA]

TYPES = [np.uint8, np.int8, np.int16, np.int32, np.int64,

np.float32, np.float64]

def availableGPUModes(self, opt, nptype):

if opt == image_ops.ResizeMethod.NEAREST_NEIGHBOR \

and nptype in [np.float32, np.float64]:

return [True, False]

else:

return [False]

def testNoOp(self):

img_shape = [1, 6, 4, 1]

single_shape = [6, 4, 1]

# This test is also conducted with int8, so 127 is the maximum

# value that can be used.

data = [127, 127, 64, 64,

127, 127, 64, 64,

64, 64, 127, 127,

64, 64, 127, 127,

50, 50, 100, 100,

50, 50, 100, 100]

target_height = 6

target_width = 4

for nptype in self.TYPES:

img_np = np.array(data, dtype=nptype).reshape(img_shape)