"""
numpy与Opencv图像类型的转换
> Python OpenCV存储图像使用的是Numpy存储，所以可以将Numpy当做图像类型操作，操作之前还需进行类型转换，转换到int8类型
"""
import cv2
import numpy as np
from PIL import Image

img = cv2.imread('./Messi.jpg')
print("shape:" + str(img.shape))
print(type(img)) #数据类型显示为numpy.ndarray

array = np.ones([20, 30])
print("shape:" + str(array.shape))
print(type(array)) #数据类型显示numpy.ndarray 与Opencv图像类型格式相同

# 可以将ndarray作为Opencv图片进行处理，但在处理之前一般进行类型转换
"""
类型转换时需注意，我参照博客转成int8类型，可以写入，但是单通道转多通道会出错
Assertion failed) VScn::contains(scn) && VDcn::contains(dcn) && VDepth::contains(depth) in function 'CvtHelper'
参照github是类型错误导致的
"""
array = np.uint8(array)
print("shape:" + str(array.shape))
cv2.imwrite('test.jpg', array)

# 类型转换
array = cv2.cvtColor(array, cv2.COLOR_GRAY2BGR)
print("shape:" + str(array.shape))
cv2.imwrite('test2.jpg', array)

"""
Opencv 图像的读，写，显示
PIL.Image的读，写，显示
"""

# Opencv读
img = cv2.imread('Messi.jpg')
# Opencv写
cv2.imwrite('Messi2.jpg', img)
# Opencv显示
cv2.imshow('Messi', img)


# PIL.Image读
img = Image.open('Messi.jpg')
# PIL.Image写
img.save('Messi3.jpg')
# PIL.Image显示
img.show()

import cv2  
from PIL import Image  
import numpy 
img = cv2.imread("Messi.jpg")
cv2.imshow("OpenCV",img)
Image.fromarray(cv2.cvtColor(img,cv2.COLOR_BGR2RGB))  

import cv2  
from PIL import Image  
import numpy  
image = Image.open("Messi.jpg")  
img = cv2.cvtColor(numpy.asarray(image),cv2.COLOR_RGB2BGR)

import cv2
from PIL import Image  
import numpy 
array = np.ones(100, 200)
Image.fromarray(array)  

import cv2
from PIL import Image
import numpy 
image = Image.open("Messi.jpg")
array = numpy.asarray(image)

a = [1, 2, 3]#a is a list
b = tuple(a) # b is a tuple
c = list(b) # c is a list

a = [1, 2, 3] # a is a list
arr = np.array(a) # arr is a ndarray
b = tuple(arr) # b is a tuple

a = (1, 2, 3)# a is a tuple
arr = np.arr(a) # arr is a ndarray
b = list(arr) # b is a list

# tensor 转numpy
array = a.numpy() # a is a tensor

# numpy 转tensor
torch.from_numpy(array) # array is a ndarray

import torch
from torchvision import transforms
from PIL import Image
import cv2

# PIL Image转tensor

transform1 = transforms.Compose([
    pass, # 这里可以写对PIL的相关操作（裁剪，旋转等）
    transforms.ToTensor(), 
    ]
)
img_PIL = Image.open('test.jpg').convert('RGB')
img_PIL_tensor = transform1(img_PIL)# 将PIL image转为tensor
print(type(img_PIL))
print(type(img_PIL_tensor))

# transforms也提供了tensor转PIL image的方法
new_img_PIL = transforms.ToPILImage()(img_PIL_Tensor).convert('RGB')

transform2 = transforms.Compose([
    pass, # transform没有对Opencv的相关操作（裁剪，旋转等）
    transforms.ToTensor(), 
    ]
)

img_Opencv = cv2.imread('test'.jpg)
img_Opencv_tensor = transform2(img_Opencv)

"""
代码功能：
1. 用dlib人脸检测器检测出人脸，返回的人脸矩形框
2. 对检测出的人脸进行关键点检测并切割出人脸
"""
import cv2
import dlib
import numpy as np

predictor_model = 'shape_predictor_68_face_landmarks.dat'
detector = dlib.get_frontal_face_detector()# dlib人脸检测器
predictor = dlib.shape_predictor(predictor_model)

# cv2读取图像
test_img_path = "input/Messi.jpg"
img = cv2.imread(test_img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# 人脸数rects
rects = detector(img, 0)
# faces存储full_object_detection对象
faces = dlib.full_object_detections()

for i in range(len(rects)):
    faces.append(predictor(img,rects[i]))

face_images = dlib.get_face_chips(img, faces, size=320)
for image in face_images:
    cv_bgr_img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    cv2.imwrite('output/Messi_clip.png', cv_bgr_img)

def get_image_hull_mask(image_shape, image_landmarks, ie_polys=None):
    # get the mask of the image
    if image_landmarks.shape[0] != 68:
        raise Exception(
            'get_image_hull_mask works only with 68 landmarks')
    int_lmrks = np.array(image_landmarks, dtype=np.int)

    #hull_mask = np.zeros(image_shape[0:2]+(1,), dtype=np.float32)
    hull_mask = np.full(image_shape[0:2] + (1,), 0, dtype=np.float32)

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[0:9],
                        int_lmrks[17:18]))), (1,))

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[8:17],
                        int_lmrks[26:27]))), (1,))

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[17:20],
                        int_lmrks[8:9]))), (1,))

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[24:27],
                        int_lmrks[8:9]))), (1,))

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[19:25],
                        int_lmrks[8:9],
                        ))), (1,))

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[17:22],
                        int_lmrks[27:28],
                        int_lmrks[31:36],
                        int_lmrks[8:9]
                        ))), (1,))

    cv2.fillConvexPoly(hull_mask, cv2.convexHull(
        np.concatenate((int_lmrks[22:27],
                        int_lmrks[27:28],
                        int_lmrks[31:36],
                        int_lmrks[8:9]
                        ))), (1,))

    # nose
    cv2.fillConvexPoly(
        hull_mask, cv2.convexHull(int_lmrks[27:36]), (1,))

    if ie_polys is not None:
        ie_polys.overlay_mask(hull_mask)
    print()
    return hull_mask

def merge_add_alpha(img_1, mask):
    # merge rgb and mask into a rgba image
    r_channel, g_channel, b_channel = cv2.split(img_1)
    if mask is not None:
        alpha_channel = np.ones(mask.shape, dtype=img_1.dtype)
        alpha_channel *= mask*255
    else:
        alpha_channel = np.zeros(img_1.shape[:2], dtype=img_1.dtype)
    img_BGRA = cv2.merge((b_channel, g_channel, r_channel, alpha_channel))
    return img_BGRA

def merge_add_mask(img_1, mask):
    if mask is not None:
        height = mask.shape[0]
        width = mask.shape[1]
        channel_num = mask.shape[2]
        for row in range(height):
            for col in range(width):
                for c in range(channel_num):
                    if mask[row, col, c] == 0:
                        mask[row, col, c] = 0
                    else:
                        mask[row, col, c] = 255

        r_channel, g_channel, b_channel = cv2.split(img_1)
        r_channel = cv2.bitwise_and(r_channel, mask)
        g_channel = cv2.bitwise_and(g_channel, mask)
        b_channel = cv2.bitwise_and(b_channel, mask)
        res_img = cv2.merge((b_channel, g_channel, r_channel))
    else:
        res_img = img_1
    return res_img

def single_face_alignment(face, landmarks):
    eye_center = ((landmarks[36, 0] + landmarks[45, 0]) * 1. / 2,  # 计算两眼的中心坐标
                  (landmarks[36, 1] + landmarks[45, 1]) * 1. / 2)
    dx = (landmarks[45, 0] - landmarks[36, 0])  # note: right - right
    dy = (landmarks[45, 1] - landmarks[36, 1])

    angle = math.atan2(dy, dx) * 180. / math.pi  # 计算角度
    RotateMatrix = cv2.getRotationMatrix2D(eye_center, angle, scale=1)  # 计算仿射矩阵
    align_face = cv2.warpAffine(face, RotateMatrix, (face.shape[0], face.shape[1]))  # 进行放射变换，即旋转
    return align_face

import torch
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

m = nn.Conv2d(16, 33, 3, stride=2)
input = torch.randn(20, 16, 50, 100)
print(m(input).size())
m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
print(m(input).size())

m = nn.Linear(20, 30)
input = torch.randn(128, 20)
output = m(input)
print(output.size())

m = nn.MaxPool2d(3, stride=2)
input = torch.randn(20, 16, 50, 32)
output = m(input)
print(output.size())

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

# 计算损失值
output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

# 反向传播前后conv1的偏置项的变化
net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

# 最简单的更新规则：随机梯度下降
# weight = weight - learning_rate * gradient

# 使用python来实现这个规则
learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

# 使用内置包
import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update 实现参数更新，一般放在反向传播后面

import torch
x = torch.ones(2, 2, requires_grad=True)
#  .requires_grad 设置为 True，则会开始跟踪针对 tensor 的所有操作
# 调用 .backward() 来自动计算所有梯度
# 调用 .detach()，它将其与计算历史记录分离
print(x)

# 针对张量进行操作
y = x + 2
print(y)

# Tensor 和 Function 互相连接并构建一个非循环图，它保存整个完整的计算过程的历史信息
# 每个张量都有一个 .grad_fn 属性保存着创建了张量的 Function 的引用
# 用户自己创建张量，则g rad_fn 是 None 
print(x.grad_fn)
print(y.grad_fn)

# 对 y 做更多的操作
z = y * y * 3
out = z.mean()

print(z, out)

# .requires_grad( ... ) 会改变张量的 requires_grad 标记。输入的标记默认为 False ，如果没有提供相应的参数。
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)

# out.backward(y) 后向传播
print(x.requires_grad, y.requires_grad, z.requires_grad)
print(out.requires_grad)
out.backward()
# 由梯度计算的链式法则算到所有的结果变量
# 所计算的梯度都是结果变量关于创建变量的梯度
# graph leaves(事先创建，而非运行得到的中间结果)
print(x.grad)

# 停止对跟踪历史中张量求导
print(x.requires_grad)
print((x ** 2).requires_grad)

with torch.no_grad():
    print((x ** 2).requires_grad)

import torch
# 构造一个5x3矩阵，不初始化。
x = torch.empty((5, 3)
print(x)

# 构造一个随机初始化的矩阵
x = torch.rand((5, 3))
print(x)

# 构造一个填充某个值的矩阵
x = torch.full((5, 3), 3.1415)
print(x)

# 构造全为0的矩阵，且数据类型为long
x = torch.zeros((5, 3), dtype = torch.long)
print(x)

# 构造单位矩阵
# torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
# Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.
torch.eye(3)

# 使用数据构造一个张量
x = torch.tensor([5.5, 3])
print(x)

# 用已经存在的tensor构造一个tensor
x = x.new_ones((5, 3), dtype = torch.double)
# new_* methods take in sizes
print(x)

x = torch.randn_like(x, dtype = torch.float)
# size和原x的size相同，但数据类型不同
print(x)

# 获取维度信息 size()
print(x.size())

# 加法1 +
y = torch.rand(5, 3)
print(x + y)

# 加法2 torch.add
# torch.add(input, alpha=1, other, out=None)
# Each element of the tensor other is multiplied by the scalar alpha and added to each element of the tensor input. The resulting tensor is returned.
print(torch.add(x, y))

# 提供一个输出tensor作为参数
result = torch.empty((5, 3))
torch.add(x, y, out = result)
print(x + y)

# add x to y  (in-place)
# 即将x+y的值赋给y
# 任何使张量会发生变化的操作都有一个前缀
y.add_(x)
print(y)

# 改变大小：如果你想改变一个 tensor 的大小或者形状，你可以使用 torch.view:

x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
print(x.size(), y.size(), z.size())