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

import math

import os

import time

import numpy as np

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

from tensorflow.core.protobuf import config_pb2

from tensorflow.python.client import session

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 control_flow_ops

from tensorflow.python.ops import gen_image_ops

from tensorflow.python.ops import image_ops

from tensorflow.python.ops import io_ops

from tensorflow.python.ops import math_ops

from tensorflow.python.ops import random_ops

from tensorflow.python.ops import variables

from tensorflow.python.platform import googletest

from tensorflow.python.platform import test

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(use_gpu=True) as sess:

batch0 = constant_op.constant(inp)

batch1 = image_ops.rgb_to_hsv(batch0)

batch2 = image_ops.hsv_to_rgb(batch1)

split0 = array_ops.unstack(batch0)

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

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

join1 = array_ops.stack(split1)

join2 = array_ops.stack(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.

with self.test_session(use_gpu=True):

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(use_gpu=True):

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(use_gpu=True):

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(use_gpu=True):

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(use_gpu=True):

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(use_gpu=True):

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(use_gpu=True):

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(use_gpu=True):

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 AdjustGamma(test_util.TensorFlowTestCase):

def test_adjust_gamma_one(self):

"""Same image should be returned for gamma equal to one"""

with self.test_session():

x_data = np.random.uniform(0, 255, (8, 8))

x_np = np.array(x_data, dtype=np.float32)

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

y = image_ops.adjust_gamma(x, gamma=1)

y_tf = y.eval()

y_np = x_np

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

def test_adjust_gamma_zero(self):

"""White image should be returned for gamma equal to zero"""

with self.test_session():

x_data = np.random.uniform(0, 255, (8, 8))

x_np = np.array(x_data, dtype=np.float32)

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

y = image_ops.adjust_gamma(x, gamma=0)

y_tf = y.eval()

dtype = x.dtype.as_numpy_dtype

y_np = np.array([dtypes.dtype_range[dtype][1]] * x_np.size)

y_np = y_np.reshape((8, 8))

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

def test_adjust_gamma_less_one(self):

"""Verifying the output with expected results for gamma

correction with gamma equal to half"""

with self.test_session():

x_np = np.arange(0, 255, 4, np.uint8).reshape(8, 8)

y = image_ops.adjust_gamma(x_np, gamma=0.5)

y_tf = np.trunc(y.eval())

y_np = np.array(

[[0, 31, 45, 55, 63, 71, 78, 84],

[90, 95, 100, 105, 110, 115, 119, 123],

[127, 131, 135, 139, 142, 146, 149, 153],

[156, 159, 162, 165, 168, 171, 174, 177],

[180, 183, 186, 188, 191, 194, 196, 199],

[201, 204, 206, 209, 211, 214, 216, 218],

[221, 223, 225, 228, 230, 232, 234, 236],

[238, 241, 243, 245, 247, 249, 251, 253]],

dtype=np.float32)

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

def test_adjust_gamma_greater_one(self):

"""Verifying the output with expected results for gamma

correction with gamma equal to two"""

with self.test_session():

x_np = np.arange(0, 255, 4, np.uint8).reshape(8, 8)

y = image_ops.adjust_gamma(x_np, gamma=2)

y_tf = np.trunc(y.eval())

y_np = np.array(

[[0, 0, 0, 0, 1, 1, 2, 3],

[4, 5, 6, 7, 9, 10, 12, 14],

[16, 18, 20, 22, 25, 27, 30, 33],

[36, 39, 42, 45, 49, 52, 56, 60],

[64, 68, 72, 76, 81, 85, 90, 95],

[100, 105, 110, 116, 121, 127, 132, 138],

[144, 150, 156, 163, 169, 176, 182, 189],

[196, 203, 211, 218, 225, 233, 241, 249]],

dtype=np.float32)

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

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(use_gpu=True):

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(use_gpu=True):

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 _adjustHueNp(self, x_np, delta_h):

self.assertEqual(x_np.shape[-1], 3)

x_v = x_np.reshape([-1, 3])

y_v = np.ndarray(x_v.shape, dtype=x_v.dtype)

channel_count = x_v.shape[0]

for i in xrange(channel_count):

r = x_v[i][0]

g = x_v[i][1]

b = x_v[i][2]

h, s, v = colorsys.rgb_to_hsv(r, g, b)

h += delta_h

h = math.fmod(h + 10.0, 1.0)

r, g, b = colorsys.hsv_to_rgb(h, s, v)

y_v[i][0] = r

y_v[i][1] = g

y_v[i][2] = b

return y_v.reshape(x_np.shape)

def _adjustHueTf(self, x_np, delta_h):

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np)

y = image_ops.adjust_hue(x, delta_h)

y_tf = y.eval()

return y_tf

def testAdjustRandomHue(self):

x_shapes = [

[2, 2, 3],

[4, 2, 3],

[2, 4, 3],

[2, 5, 3],

[1000, 1, 3],

]

test_styles = [

'all_random',

'rg_same',

'rb_same',

'gb_same',

'rgb_same',

]

for x_shape in x_shapes:

for test_style in test_styles:

x_np = np.random.rand(*x_shape) * 255.

delta_h = np.random.rand() * 2.0 - 1.0

if test_style == 'all_random':

pass

elif test_style == 'rg_same':

x_np[..., 1] = x_np[..., 0]

elif test_style == 'rb_same':

x_np[..., 2] = x_np[..., 0]

elif test_style == 'gb_same':

x_np[..., 2] = x_np[..., 1]

elif test_style == 'rgb_same':

x_np[..., 1] = x_np[..., 0]

x_np[..., 2] = x_np[..., 0]

else:

raise AssertionError('Invalid test style: %s' % (test_style))

y_np = self._adjustHueNp(x_np, delta_h)

y_tf = self._adjustHueTf(x_np, delta_h)

self.assertAllClose(y_tf, y_np, rtol=2e-5, atol=1e-5)

def testInvalidShapes(self):

fused = False

if not fused:

# The tests are known to pass with the fused adjust_hue. We will enable

# them when the fused implementation is the default.

return

x_np = np.random.rand(2, 3) * 255.

delta_h = np.random.rand() * 2.0 - 1.0

fused = False

with self.assertRaisesRegexp(ValueError, 'Shape must be at least rank 3'):

self._adjustHueTf(x_np, delta_h)

x_np = np.random.rand(4, 2, 4) * 255.

delta_h = np.random.rand() * 2.0 - 1.0

with self.assertRaisesOpError('input must have 3 channels'):

self._adjustHueTf(x_np, delta_h)

class AdjustHueBenchmark(test.Benchmark):

def _benchmarkAdjustHue(self, device, cpu_count):

image_shape = [299, 299, 3]

warmup_rounds = 100

benchmark_rounds = 1000

config = config_pb2.ConfigProto()

if cpu_count is not None:

config.inter_op_parallelism_threads = 1

config.intra_op_parallelism_threads = cpu_count

with session.Session('', graph=ops.Graph(), config=config) as sess:

with ops.device(device):

inputs = variables.Variable(

random_ops.random_uniform(

image_shape, dtype=dtypes.float32) * 255,

trainable=False,

dtype=dtypes.float32)

delta = constant_op.constant(0.1, dtype=dtypes.float32)

outputs = image_ops.adjust_hue(inputs, delta)

run_op = control_flow_ops.group(outputs)

sess.run(variables.global_variables_initializer())

for i in xrange(warmup_rounds + benchmark_rounds):

if i == warmup_rounds:

start = time.time()

sess.run(run_op)

end = time.time()

step_time = (end - start) / benchmark_rounds

tag = '%s' % (cpu_count) if cpu_count is not None else '_all'

print('benchmarkAdjustHue_299_299_3_cpu%s step_time: %.2f us' %

(tag, step_time * 1e6))

self.report_benchmark(

name='benchmarkAdjustHue_299_299_3_cpu%s' % (tag),

iters=benchmark_rounds,

wall_time=step_time)

def benchmarkAdjustHueCpu1(self):

self._benchmarkAdjustHue('/cpu:0', 1)

def benchmarkAdjustHueCpuAll(self):

self._benchmarkAdjustHue('/cpu:0', None)

def benchmarkAdjustHueGpu(self):

self._benchmarkAdjustHue(test.gpu_device_name(), None)

class AdjustSaturationBenchmark(test.Benchmark):

def _benchmarkAdjustSaturation(self, device, cpu_count):

image_shape = [299, 299, 3]

warmup_rounds = 100

benchmark_rounds = 1000

config = config_pb2.ConfigProto()

if cpu_count is not None:

config.inter_op_parallelism_threads = 1

config.intra_op_parallelism_threads = cpu_count

with session.Session('', graph=ops.Graph(), config=config) as sess:

with ops.device(device):

inputs = variables.Variable(

random_ops.random_uniform(

image_shape, dtype=dtypes.float32) * 255,

trainable=False,

dtype=dtypes.float32)

delta = constant_op.constant(0.1, dtype=dtypes.float32)

outputs = image_ops.adjust_saturation(inputs, delta)

run_op = control_flow_ops.group(outputs)

sess.run(variables.global_variables_initializer())

for _ in xrange(warmup_rounds):

sess.run(run_op)

start = time.time()

for _ in xrange(benchmark_rounds):

sess.run(run_op)

end = time.time()

step_time = (end - start) / benchmark_rounds

tag = '%s' % (cpu_count) if cpu_count is not None else '_all'

print('benchmarkAdjustSaturation_599_599_3_cpu%s step_time: %.2f us' %

(tag, step_time * 1e6))

self.report_benchmark(

name='benchmarkAdjustSaturation_599_599_3_cpu%s' % (tag),

iters=benchmark_rounds,

wall_time=step_time)

def benchmarkAdjustSaturationCpu1(self):

self._benchmarkAdjustSaturation('/cpu:0', 1)

def benchmarkAdjustSaturationCpuAll(self):

self._benchmarkAdjustSaturation('/cpu:0', None)

def benchmarkAdjustSaturationGpu(self):

self._benchmarkAdjustSaturation(test.gpu_device_name(), None)

class ResizeBilinearBenchmark(test.Benchmark):

def _benchmarkResize(self, image_size, num_channels):

batch_size = 1

num_ops = 1000

img = variables.Variable(

random_ops.random_normal(

[batch_size, image_size[0], image_size[1], num_channels]),

name='img')

deps = []

for _ in xrange(num_ops):

with ops.control_dependencies(deps):

resize_op = image_ops.resize_bilinear(

img, [299, 299], align_corners=False)

deps = [resize_op]

benchmark_op = control_flow_ops.group(*deps)

with session.Session() as sess:

sess.run(variables.global_variables_initializer())

results = self.run_op_benchmark(

sess,

benchmark_op,

name=('resize_bilinear_%s_%s_%s' %

(image_size[0], image_size[1], num_channels)))

print('%s : %.2f ms/img' % (results['name'], 1000 * results['wall_time']

/ (batch_size * num_ops)))

def benchmarkSimilar3Channel(self):

self._benchmarkResize((183, 229), 3)

def benchmarkScaleUp3Channel(self):

self._benchmarkResize((141, 186), 3)

def benchmarkScaleDown3Channel(self):

self._benchmarkResize((749, 603), 3)

def benchmarkSimilar1Channel(self):

self._benchmarkResize((183, 229), 1)

def benchmarkScaleUp1Channel(self):

self._benchmarkResize((141, 186), 1)

def benchmarkScaleDown1Channel(self):

self._benchmarkResize((749, 603), 1)

class ResizeBicubicBenchmark(test.Benchmark):

def _benchmarkResize(self, image_size, num_channels):

batch_size = 1

num_ops = 1000

img = variables.Variable(

random_ops.random_normal(

[batch_size, image_size[0], image_size[1], num_channels]),

name='img')

deps = []

for _ in xrange(num_ops):

with ops.control_dependencies(deps):

resize_op = image_ops.resize_bicubic(

img, [299, 299], align_corners=False)

deps = [resize_op]

benchmark_op = control_flow_ops.group(*deps)

with session.Session() as sess:

sess.run(variables.global_variables_initializer())

results = self.run_op_benchmark(

sess,

benchmark_op,

min_iters=20,

name=('resize_bicubic_%s_%s_%s' % (image_size[0], image_size[1],

num_channels)))

print('%s : %.2f ms/img' % (results['name'], 1000 * results['wall_time']

/ (batch_size * num_ops)))

def benchmarkSimilar3Channel(self):

self._benchmarkResize((183, 229), 3)

def benchmarkScaleUp3Channel(self):

self._benchmarkResize((141, 186), 3)

def benchmarkScaleDown3Channel(self):

self._benchmarkResize((749, 603), 3)

def benchmarkSimilar1Channel(self):

self._benchmarkResize((183, 229), 1)

def benchmarkScaleUp1Channel(self):

self._benchmarkResize((141, 186), 1)

def benchmarkScaleDown1Channel(self):

self._benchmarkResize((749, 603), 1)

def benchmarkSimilar4Channel(self):

self._benchmarkResize((183, 229), 4)

def benchmarkScaleUp4Channel(self):

self._benchmarkResize((141, 186), 4)

def benchmarkScaleDown4Channel(self):

self._benchmarkResize((749, 603), 4)

class ResizeAreaBenchmark(test.Benchmark):

def _benchmarkResize(self, image_size, num_channels):

batch_size = 1

num_ops = 1000

img = variables.Variable(

random_ops.random_normal([batch_size, image_size[0],

image_size[1], num_channels]),

name='img')

deps = []

for _ in xrange(num_ops):

with ops.control_dependencies(deps):

resize_op = image_ops.resize_area(img, [299, 299], align_corners=False)

deps = [resize_op]

benchmark_op = control_flow_ops.group(*deps)

with session.Session() as sess:

sess.run(variables.global_variables_initializer())

results = self.run_op_benchmark(

sess, benchmark_op,

name=('resize_area_%s_%s_%s' %

(image_size[0], image_size[1], num_channels)))

print('%s : %.2f ms/img' % (

results['name'],

1000*results['wall_time'] / (batch_size * num_ops)))

def benchmarkSimilar3Channel(self):

self._benchmarkResize((183, 229), 3)

def benchmarkScaleUp3Channel(self):

self._benchmarkResize((141, 186), 3)

def benchmarkScaleDown3Channel(self):

self._benchmarkResize((749, 603), 3)

def benchmarkSimilar1Channel(self):

self._benchmarkResize((183, 229), 1)

def benchmarkScaleUp1Channel(self):

self._benchmarkResize((141, 186), 1)

def benchmarkScaleDown1Channel(self):

self._benchmarkResize((749, 603), 1)

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(use_gpu=True):

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(use_gpu=True):

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 _adjust_saturation(self, image, saturation_factor):

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

orig_dtype = image.dtype

flt_image = image_ops.convert_image_dtype(image, dtypes.float32)

saturation_adjusted_image = gen_image_ops.adjust_saturation(

flt_image, saturation_factor)

return image_ops.convert_image_dtype(saturation_adjusted_image,

orig_dtype)

def testHalfSaturationFused(self):

x_shape = [2, 2, 3]

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

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

saturation_factor = 0.5

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

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

with self.test_session(use_gpu=True):

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

y = self._adjust_saturation(x, saturation_factor)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def testTwiceSaturationFused(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(use_gpu=True):

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

y = self._adjust_saturation(x, saturation_factor)

y_tf = y.eval()

self.assertAllEqual(y_tf, y_np)

def _adjustSaturationNp(self, x_np, scale):

self.assertEqual(x_np.shape[-1], 3)

x_v = x_np.reshape([-1, 3])

y_v = np.ndarray(x_v.shape, dtype=x_v.dtype)

channel_count = x_v.shape[0]

for i in xrange(channel_count):

r = x_v[i][0]

g = x_v[i][1]

b = x_v[i][2]

h, s, v = colorsys.rgb_to_hsv(r, g, b)

s *= scale

s = min(1.0, max(0.0, s))

r, g, b = colorsys.hsv_to_rgb(h, s, v)

y_v[i][0] = r

y_v[i][1] = g

y_v[i][2] = b

return y_v.reshape(x_np.shape)

def testAdjustRandomSaturation(self):

x_shapes = [

[2, 2, 3],

[4, 2, 3],

[2, 4, 3],

[2, 5, 3],

[1000, 1, 3],

]

test_styles = [

'all_random',

'rg_same',

'rb_same',

'gb_same',

'rgb_same',

]

with self.test_session():

for x_shape in x_shapes:

for test_style in test_styles:

x_np = np.random.rand(*x_shape) * 255.

scale = np.random.rand()

if test_style == 'all_random':

pass

elif test_style == 'rg_same':

x_np[..., 1] = x_np[..., 0]

elif test_style == 'rb_same':

x_np[..., 2] = x_np[..., 0]

elif test_style == 'gb_same':

x_np[..., 2] = x_np[..., 1]

elif test_style == 'rgb_same':

x_np[..., 1] = x_np[..., 0]

x_np[..., 2] = x_np[..., 0]

else:

raise AssertionError('Invalid test style: %s' % (test_style))

y_baseline = self._adjustSaturationNp(x_np, scale)

y_fused = self._adjust_saturation(x_np, scale).eval()

self.assertAllClose(y_fused, y_baseline, rtol=2e-5, atol=1e-5)

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

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

y = image_ops.random_flip_left_right(x_tf)

count_flipped = 0

count_unflipped = 0

for _ in range(50):

y_tf = y.eval()

if y_tf[0][0] == 1:

self.assertAllEqual(y_tf, x_np)

count_unflipped += 1

else:

self.assertAllEqual(y_tf, y_np)

count_flipped += 1

self.assertGreaterEqual(count_flipped, 1)

self.assertGreaterEqual(count_unflipped, 1)

def testIdempotentUpDown(self):

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

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

y = image_ops.random_flip_up_down(x_tf)

count_flipped = 0

count_unflipped = 0

for _ in range(50):

y_tf = y.eval()

if y_tf[0][0] == 1:

self.assertAllEqual(y_tf, x_np)

count_unflipped += 1

else:

self.assertAllEqual(y_tf, y_np)

count_flipped += 1

self.assertGreaterEqual(count_flipped, 1)

self.assertGreaterEqual(count_unflipped, 1)

def testIdempotentTranspose(self):

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

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

with self.test_session(use_gpu=True):

k_placeholder = array_ops.placeholder(dtypes.int32, shape=[])

y_tf = image_ops.rot90(image, k_placeholder)

for k in xrange(4):

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

self.assertAllEqual(y_np, y_tf.eval({k_placeholder: k}))

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(use_gpu=True):

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(use_gpu=True):

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

with self.test_session(use_gpu=True):

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)

def _adjustContrastNp(self, x_np, contrast_factor):

mean = np.mean(x_np, (1, 2), keepdims=True)

y_np = mean + contrast_factor * (x_np - mean)

return y_np

def _adjustContrastTf(self, x_np, contrast_factor):

with self.test_session(use_gpu=True):

x = constant_op.constant(x_np)

y = image_ops.adjust_contrast(x, contrast_factor)

y_tf = y.eval()

return y_tf

def testRandomContrast(self):

x_shapes = [

[1, 2, 2, 3],

[2, 1, 2, 3],

[1, 2, 2, 3],

[2, 5, 5, 3],

[2, 1, 1, 3],

]

for x_shape in x_shapes:

x_np = np.random.rand(*x_shape) * 255.

contrast_factor = np.random.rand() * 2.0 + 0.1

y_np = self._adjustContrastNp(x_np, contrast_factor)

y_tf = self._adjustContrastTf(x_np, contrast_factor)

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

class AdjustBrightnessTest(test_util.TensorFlowTestCase):

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

with self.test_session(use_gpu=True):

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)