%pylab inline
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

def __int64__feature(value):
    '''生成整数型的属性'''
    return tf.train.Feature(int64_list= tf.train.Int64List(value=[value]))

def __bytes__feature(value):
    '''生成字符型的属性'''
    return tf.train.Feature(bytes_list= tf.train.BytesList(value=[value]))

mnist = input_data.read_data_sets('E:/datasets/mnist/data', dtype= tf.uint8, one_hot= True)

images = mnist.train.images
# 训练数据所对应的正确答案，可以作为一个属性保存在 TFRecord 中
labels = mnist.train.labels

# 训练数据的图像分辨率，这可以作为 Example 中的一个属性
pixels = images.shape[1]
num_examples = mnist.train.num_examples

# 输出 TFRecord 文件的地址
filename = 'E:/datasets/mnist/output.tfrecords'
# 创建一个 writer 来写 TFRecord 文件
writer = tf.python_io.TFRecordWriter(filename)
for index in range(num_examples):
    # 将图片矩阵转化为一个字符串
    image_raw = images[index].tostring()
    # 将一个样例转换为 Example Protocol Buffer，并将所有的信息写入到这个数据结构
    examle = tf.train.Example(features = tf.train.Features(feature={
        'pixels': __int64__feature(pixels),
        'label': __int64__feature(np.argmax(labels[index])),
        'image_raw': __bytes__feature(image_raw)
    }))
    
    # 将一个 Example 写入 TFRecord 文件
    writer.write(examle.SerializeToString())
writer.close()

import tensorflow as tf

# 创建一个 reader 来读取 TFRecord 文件中的样例
reader = tf.TFRecordReader()
# 创建一个队列来维护输入文件列表
filename_queue = tf.train.string_input_producer(['E:/datasets/mnist/output.tfrecords'])

# 从文件中读出一个样例。也可使用 read_up_to 函数一次性读取多个样例
_, serialized_example = reader.read(filename_queue)
# 解析读入的一个样例。如果需要解析多个样例，可以用 parse_example 函数
features = tf.parse_single_example(serialized_example,
                                  features= {
                                      # TensorFlow 提供两种不同的属性解析方法。一种是 tf.FixedLenFeature，解析结果为一个 Tensor
                                      # 另一种方法为 tf.VarLenFeature，解析结果为 SparseTensor，用于处理稀疏数据
                                      # 解析数据的格式需要和写入数据的格式一致
                                      'image_raw': tf.FixedLenFeature([], tf.string),
                                      'pixels': tf.FixedLenFeature([], tf.int64),
                                      'label': tf.FixedLenFeature([], tf.int64),
                                  })

# tf.decode_raw 可以将字符串解析成图片对应的像素数组
images = tf.decode_raw(features['image_raw'], tf.uint8)
labels = tf.cast(features['label'], tf.int32)
pixels = tf.cast(features['pixels'], tf.int32)

sess = tf.Session() 
# 启动多线程
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess= sess, coord= coord)
    
# 每次运行可以读取 TFRecord 文件中的一个样例。当所有样例都读完之后，在此样例中程序会再重头读取
for i in range(10):
    image, label, pixel = sess.run([images, labels, pixels])
    
sess.close()

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

# 读取图像的原始数据
image_raw_data = tf.gfile.FastGFile('E:/datasets/cat.jpg', 'rb').read()  # 必须是 ‘rb’ 模式打开，否则会报错

with tf.Session() as sess:
    # 将图像使用 jpeg 的格式解码从而得到图像对应的三维矩阵
    # tf.image.decode_jpeg 函数对 png 格式的图像进行解码。解码之后的结果为一个张量，
    ## 在使用它的取值之前需要明确调用运行的过程。
    img_data = tf.image.decode_jpeg(image_raw_data)
    
    # 输出解码之后的三维矩阵。
    print(img_data.eval())

with tf.Session() as sess:
    plt.imshow(img_data.eval())
    plt.show()

with tf.Session() as sess:
    # 数据类型转换为实数方便程序对图像进行处理
    img_data = tf.image.convert_image_dtype(img_data, dtype= tf.float32)
    img_data = tf.image.convert_image_dtype(img_data, dtype= tf.uint8)
    
    # 将表示一张图片的三维矩阵重新按照 jpeg 格式编码并存入文件中
    ## 打开这张图像，可以得到和原始图像一样的图像
    encoded_image = tf.image.encode_jpeg(img_data)
    with tf.gfile.GFile('E:/datasets/output.jpg', 'wb') as f:
        f.write(encoded_image.eval())

with tf.Session() as sess:    
    resized = tf.image.resize_images(img_data, [300, 300], method=0)
    
    # TensorFlow的函数处理图片后存储的数据是float32格式的，需要转换成uint8才能正确打印图片。
    print("Digital type: ", resized.dtype)
    print("Digital shape: ", resized.get_shape())
    cat = np.asarray(resized.eval(), dtype='uint8')
    # tf.image.convert_image_dtype(rgb_image, tf.float32)
    plt.imshow(cat)
    plt.show()

with tf.Session() as sess:    
    croped = tf.image.resize_image_with_crop_or_pad(img_data, 1000, 1000)
    padded = tf.image.resize_image_with_crop_or_pad(img_data, 3000, 3000)
    plt.imshow(croped.eval())
    plt.show()
    plt.imshow(padded.eval())
    plt.show()

with tf.Session() as sess:   
    central_cropped = tf.image.central_crop(img_data, 0.5)
    plt.imshow(central_cropped.eval())
    plt.show()

with tf.Session() as sess: 
    # 上下翻转
    flipped1 = tf.image.flip_up_down(img_data)
    plt.imshow(flipped1.eval())
    plt.show()
    # 左右翻转
    flipped2 = tf.image.flip_left_right(img_data)
    plt.imshow(flipped2.eval())
    plt.show()
    
    #对角线翻转
    transposed = tf.image.transpose_image(img_data)
    plt.imshow(transposed.eval())
    plt.show()

with tf.Session() as sess:    
    # 以一定概率上下翻转图片。
    flipped = tf.image.random_flip_up_down(img_data)
    plt.imshow(flipped.eval())
    plt.show()
    
    # 以一定概率左右翻转图片。
    flipped = tf.image.random_flip_left_right(img_data)
    plt.imshow(flipped.eval())
    plt.show()

with tf.Session() as sess:     
    # 将图片的亮度 -0.5。
    adjusted = tf.image.adjust_brightness(img_data, -0.5)
    plt.imshow(adjusted.eval())
    plt.show()
    
    # 将图片的亮度 +0.5
    adjusted = tf.image.adjust_brightness(img_data, 0.5)
    plt.imshow(adjusted.eval())
    plt.show() 
    
    # 在[-max_delta, max_delta)的范围随机调整图片的亮度。
    adjusted = tf.image.random_brightness(img_data, max_delta=0.5)
    plt.imshow(adjusted.eval())
    plt.show()

with tf.Session() as sess:
    # 将图片的对比度 -5
    adjusted = tf.image.adjust_contrast(img_data, -5)
    plt.imshow(adjusted.eval())
    plt.show()
    
    # 将图片的对比度 +5
    adjusted = tf.image.adjust_contrast(img_data, 5)
    plt.imshow(adjusted.eval())
    plt.show()
    
    # 在[lower, upper]的范围随机调整图的对比度。
    lower = 7
    upper = 88
    adjusted = tf.image.random_contrast(img_data, lower, upper)
    plt.imshow(adjusted.eval())
    plt.show()

with tf.Session() as sess:   
    '''调节色相'''
    adjusted = tf.image.adjust_hue(img_data, 0.1)
    plt.imshow(adjusted.eval())
    plt.show()
    
    adjusted = tf.image.adjust_hue(img_data, 0.3)
    plt.imshow(adjusted.eval())
    plt.show()
    
    adjusted = tf.image.adjust_hue(img_data, 0.6)
    plt.imshow(adjusted.eval())
    plt.show()
    
    adjusted = tf.image.adjust_hue(img_data, 0.9)
    plt.imshow(adjusted.eval())
    plt.show()
    
    # 在[-max_delta, max_delta]的范围随机调整图片的色相。max_delta的取值在[0, 0.5]之间。
    adjusted = tf.image.random_hue(img_data, 0.5)
    plt.imshow(adjusted.eval())
    plt.show()

with tf.Session() as sess:
    # 将图片的饱和度-5。
    adjusted = tf.image.adjust_saturation(img_data, -5)
    plt.imshow(adjusted.eval())
    plt.show()
    
    # 将图片的饱和度+5。
    adjusted = tf.image.adjust_saturation(img_data, 5)
    plt.imshow(adjusted.eval())
    plt.show()
    
    # 在[lower, upper]的范围随机调整图的饱和度。
    #adjusted = tf.image.random_saturation(img_data, lower, upper)

with tf.Session() as sess:
    # 将代表一张图片的三维矩阵中的数字均值变为0，方差变为1。
    image = img.imread('E:/datasets/cat.jpg')
    adjusted = tf.image.per_image_standardization(image)
    cat = np.asarray(adjusted.eval(), dtype='uint8')
    plt.imshow(cat)  # imshow 仅支持 uint8 格式
    plt.show()

import tensorflow as tf
import matplotlib.image as img
import matplotlib.pyplot as plt
import numpy as np
sess = tf.InteractiveSession()
image = img.imread('E:/datasets/cat.jpg')
shape = tf.shape(image).eval()
h,w = shape[0],shape[1]
standardization_image = tf.image.per_image_standardization(image)  #标准化

fig = plt.figure()
fig1 = plt.figure()
ax = fig.add_subplot(111)
ax.set_title('orginal image')
ax.imshow(image)
ax1 = fig1.add_subplot(311)
ax1.set_title('original hist')
ax1.hist(sess.run(tf.reshape(image,[h*w,-1])))
ax1 = fig1.add_subplot(313)
ax1.set_title('standardization hist')
ax1.hist(sess.run(tf.reshape(standardization_image,[h*w,-1])))
plt.ion()
plt.show()

with tf.Session() as sess:
    # 将图像缩小一些，这样可视化能够让标注框更加清晰
    img_data = tf.image.resize_images(img_data, [180, 267], method= 1)
    # tf.image.draw_bounding_boxes 函数要求图像矩阵中的数字为实数类型。
    # tf.image.draw_bounding_boxes 函数的输入是一个 batch 的数据，也就是多张图像组成的四维矩阵，所以需要将解码后的图像加一维
    batched = tf.expand_dims(tf.image.convert_image_dtype(img_data, tf.float32), 0)
    # 给出每张图像的所有标注框。一个标注框有四个数字，分别代表 [y_min, x_min, y_max, x_max] 
    ## 注意这里给出的数字都是图像的相对位置。比如在 180 * 267 的图像中 [0.35, 0.47, 0.5, 0.56] 代表了从 (63, 125) 到 (90, 150)
    ### 的图像。
    boxes = tf.constant([[[0.05, 0.05, 0.9, 0.7], [0.35, 0.47, 0.5, 0.56]]])
    result = tf.image.draw_bounding_boxes(batched, boxes)
    plt.imshow(result[0].eval())
    plt.show()

with tf.Session() as sess:         
    boxes = tf.constant([[[0.05, 0.05, 0.9, 0.7], [0.35, 0.47, 0.5, 0.56]]])
    # 可以通过提供随机标注框的方式来告诉随机截取图像的算法哪些部分是 “有信息量” 的。
    begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
        tf.shape(img_data), bounding_boxes=boxes)
    
    # 通过标注框可视化随机截取得到的图像
    batched = tf.expand_dims(tf.image.convert_image_dtype(img_data, tf.float32), 0) 
    image_with_box = tf.image.draw_bounding_boxes(batched, bbox_for_draw)
    plt.imshow(image_with_box[0].eval())
    plt.show()
    
    # 截取随机出来的图像，因为算法带有随机成分，所以每次的结果都可能不相同
    distorted_image = tf.slice(img_data, begin, size)
    plt.imshow(distorted_image.eval())
    plt.show()