image_ops.ipynb

Kernel: Python 3

Copyright 2020 The TensorFlow Authors.

#@title 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
#
# https://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.

Operações de imagens do TensorFlow Addons

Ver em TensorFlow.org

Executar no Google Colab

Ver fonte no GitHub

Baixar notebook

Visão geral

Este notebook demonstra como usar algumas operações de imagens no TensorFlow Addons.

Confira a lista de operações de imagens abordadas neste exemplo:

• tfa.image.mean_filter2d

• tfa.image.rotate

• tfa.image.transform

• tfa.image.random_hsv_in_yiq

• tfa.image.adjust_hsv_in_yiq

• tfa.image.dense_image_warp

• tfa.image.euclidean_dist_transform

Configuração

!pip install -U tensorflow-addons

import tensorflow as tf
import numpy as np
import tensorflow_addons as tfa
import matplotlib.pyplot as plt

Prepare e inspecione as imagens

Baixe as imagens

img_path = tf.keras.utils.get_file('tensorflow.png','https://tensorflow.org/images/tf_logo.png')

Inspecione as imagens

Ícone do TensorFlow

img_raw = tf.io.read_file(img_path)
img = tf.io.decode_image(img_raw)
img = tf.image.convert_image_dtype(img, tf.float32)
img = tf.image.resize(img, [500,500])

plt.title("TensorFlow Logo with shape {}".format(img.shape))
_ = plt.imshow(img)

Crie uma versão em preto e branco

bw_img = 1.0 - tf.image.rgb_to_grayscale(img)

plt.title("Mask image with shape {}".format(bw_img.shape))
_ = plt.imshow(bw_img[...,0], cmap='gray')

Brinque com o tfa.image

Mean filtering

Mean filtering é uma técnica de filtragem geralmente usada para remover ruído de uma imagem ou um sinal. A ideia é percorrer a imagem pixel por pixel e substituir por valores médios de pixels vizinhos.

mean = tfa.image.mean_filter2d(img, filter_shape=11)
_ = plt.imshow(mean)

Rotate

Essa operação gira uma determinada imagem no ângulo (em radianos) inserido pelo usuário.

rotate = tfa.image.rotate(img, tf.constant(np.pi/8))
_ = plt.imshow(rotate)

Transform

Essa operação transforma uma determina imagem com base no vetor de transformação fornecido pelo usuário.

transform = tfa.image.transform(img, [1.0, 1.0, -250, 0.0, 1.0, 0.0, 0.0, 0.0])
_ = plt.imshow(transform)

Random HSV in YIQ

Essa operação muda a escala de cor de uma determinada imagem RGB para YIQ, mas os valores de matiz e saturação delta são escolhidos de maneira aleatória no intervalo indicado.

delta = 0.5
lower_saturation = 0.1
upper_saturation = 0.9
lower_value = 0.2
upper_value = 0.8
rand_hsvinyiq = tfa.image.random_hsv_in_yiq(img, delta, lower_saturation, upper_saturation, lower_value, upper_value)
_ = plt.imshow(rand_hsvinyiq)

Adjust HSV in YIQ

Essa operação muda a escala de cor de uma determinada imagem RGB para YIQ, mas, em vez de escolhidos aleatoriamente, os valores de matiz e saturação delta são indicados pelo usuário.

delta = 0.5
saturation = 0.3
value = 0.6
adj_hsvinyiq = tfa.image.adjust_hsv_in_yiq(img, delta, saturation, value)
_ = plt.imshow(adj_hsvinyiq)

Dense Image Warp

Essa operação serve para a distorção não linear de qualquer imagem especificada pelo campo de fluxo do vetor de deslocamento (como exemplo, são usados valores aleatórios).

input_img = tf.image.convert_image_dtype(tf.expand_dims(img, 0), tf.dtypes.float32)

flow_shape = [1, input_img.shape[1], input_img.shape[2], 2]
init_flows = np.float32(np.random.normal(size=flow_shape) * 2.0)
dense_img_warp = tfa.image.dense_image_warp(input_img, init_flows)
dense_img_warp = tf.squeeze(dense_img_warp, 0)
_ = plt.imshow(dense_img_warp)

Euclidian Distance Transform

Essa operação atualiza o valor de pixel com a distância euclidiana do pixel em primeiro plano para o pixel em segundo plano.

• Observação: só aceita uma imagem binária e resulta em uma imagem transformada. Caso seja fornecida uma imagem diferente, isso resulta em uma imagem com um único valor

gray = tf.image.convert_image_dtype(bw_img,tf.uint8)
# The op expects a batch of images, so add a batch dimension
gray = tf.expand_dims(gray, 0)
eucid = tfa.image.euclidean_dist_transform(gray)
eucid = tf.squeeze(eucid, (0, -1))
_ = plt.imshow(eucid, cmap='gray')