开始图像处理的海洋

(1)两个问题的详细解答

在开始畅游opencv、tensorflow的海洋之前，我们这里先要解决两个问题。

1.Jupyter notebook 解决了无法自动跳转到浏览器的问题

1)在开始菜单里找到并打开Anaconda Prompt，输入以下命令然后执行。

jupyter notebook --generate-config

2)打开上述命令生成的jupyter notebook配置文件：jupyter_notebook_config.py。找到# c.NotebookApp.browser = ''这一行，将其修改为如下所示。

c.NotebookApp.browser = 'chrome'
import webbrowser
webbrowser.register('chrome',None,webbrowser.GenericBrowser(u'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe'))

这样就完成了将Jupyter notebook自动跳转到到浏览器的问题。

2.Jupyter notebook 解决了修改默认启动目录的问题

1)打开上一步生成的配置文件
C:\Users\Administrator.jupyter\jupyter_notebook_config.py

2)在jupyter_notebook_config.py中找到并修改如下配置项 :

#c.NotebookApp.notebook_dir = ‘’

删除前面的 # 号，在后面的单引号里输入要设置的目录路径，保存关闭。比如我要默认打开的路径为D:\Python\data_science

步骤3：修改jupyter notebook的快捷方式
在开始菜单中找到jupyter notebook快捷方式的位置，鼠标右键>>属性>>快捷方式>>目标
删除最后的 “%USERPROFILE%/” 。

好了，现在单击修改过的jupyter notebook快捷方式，默认打开的目录就是自己修改的目录了。为了方便，可以把修改过的快捷方式放到桌面或者固定到“开始”屏幕。

(2)测试案例：hello world

验证我们搭建的tensorflow开发环境的搭建是否成功。

接下来我们打开Jupyter notebook来做一个hello world的测试案例。

# 1 import进行模块的引入  2 string  3 print
import tensorflow as tf
# 问题产生的原因：无法执行sess.run()的原因是tensorflow版本不同导致的，tensorflow版本2.0无法兼容版本1.0.
# 解决办法：
# tf.compat.v1.disable_eager_execution()
tf.compat.v1.disable_eager_execution()
# 使用TensorFlow输出Hello
# 创建一个常量操作( Constant op )
# 这个 op 会被作为一个节点( node )添加到默认计算图上.
#
# 该构造函数返回的值就是常量节点(Constant op)的输出.
hello = tf.constant('hello world')

sess = tf.compat.v1.Session()
print(sess.run(hello))
sess.close()
# 后记：（１）对问题的认知，能够帮助自己快速定位问题。
# 　　　　　　开始定位问题时，太懒，直接连英文的意思都没搞懂，就直接粘贴到百度去搜索，于是根本无法找到合适的答案。
# 　　　（２）明确问题，这个问题是图是空的，然后我去查看图建立的方法，没错，就是这样建立的。然后怀疑可能时无法执行sess.run()。
# 　　　（３）遇到问题，一定要深入思考一下，才是问题的根因，直接依据问题的表面去查找答案，根本无法找到。

# 输出的结果为：b'hello world'

通过hello world的测试案例可知，我们搭建的环境是有用的，一切行之有效。那么接下来，我们要去做更多好玩的趣味的图像处理的知识。

(3)案例1：图片的读取和展示

我们利用opencv实现图片的读取和展示。并测试下载安装的opencv是否有用。

代码如下所示：

# 1 import引入opencv模块 2 调用api 3 stop的操作
import cv2

img = cv2.imread('image0.JPG',1) # 该方法实现了图片的读取（read image）。read方法的第一个参数是图片的名称，第二个参数是描述的是图片的类型。
# 第二个参数如果是0，读取的是灰色图片。第二个参数如果是1，读取的是彩色图片。
cv2.imshow('image',img)# 参数1：显示图片的窗口名称。参数2：储存图片数据的对象。
cv2.waitKey(0)# 实现正常的退出。

(4)opencv模块组织结构

下载win或ios的pack，里面有响应模块源代码：

calib3d模块主要用于相机等
core模块非常重要，完全掌握，core中包括opencv的绘图操作等基础部分
dnn模块和神经网络相关
features2d模块和图像焦点检测相关，比如做图像匹配
higngui模块和图像交互相关，很重要，在当前课程使用较少
imgcodecs很重要
mi模块也很重要
photo模块图片处理
shape模块
stitch模块，图片连接等操作
video描述视频信息

(5)案例2：图片的写入

import cv2
img = cv2.imread('image0.JPG',1)
image = cv2.imwrite('image1.jpg',img)# image没有返回值。所以我们显示imshow()的图片为空图片。
# imwrite有两个参数，参数一：是描述文件的名称。png/jpg，参数二：是传入解码之后的图片的数据
cv2.imshow('image1',image)# 展示出来的图片是空的图片
cv2.waitKey(0)# 实现正常的退出。

(6)案例3：图片的压缩

# jpg图片的压缩  1.有损压缩 数字是0-100之间 2.无法描绘透明度属性
import cv2
img = cv2.imread('image0.JPG',1)
cv2.imwrite('imageTest.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,0])
# 参数一：要写入的文件的名称，参数二：文件解码后的数据 参数三：文件的质量,这里的图片质量就变的很差了。以牺牲图片的质量为代价
# 1M -》100K-》10K的图片质量会严重失真。图片的质量的数字是0-100之间。有损压缩。

# png图片的压缩  1.无损压缩 数字是0-9之间 2。描绘透明度属性
import cv2
img = cv2.imread('image0.JPG',1)
cv2.imwrite('imageTest.png',img,[cv2.IMWRITE_PNG_COMPRESSION,5])


# jpg 0 压缩比越大（高），图片质量损失严重  0-100     png 0 压缩比越小（低），图片质量越接近原图   0-9

(7)像素操作基础

1 像素 图片中的一个一个小方块。图片中的一个小方块就是一个像素。

2 rgb（203,203,9）

3 颜色深度 8bit 0-255

4 图片的宽w和图片的h 640*480

表示的是在水平方向有640个像素点，在竖直方向有480个像素点。

5 1.14M = 720X547X3X8bit /8(B)=1.14M 720X547表示多少个像素，3表示rgb的颜色三种，一种颜色有8bit组成。所以我们就可以算出一张图片的大小。

6 RGB alpha(透明度)

7 RGB bgr

8 bgr b(blue蓝色) g(green绿色) r(red红色)

9 像素的读取和写入：

import cv2
img = cv2.imread('image0.JPG',1)
(b,g,r) = img[100,100]
print(b,g,r)

for i in range(1,100):
    img[10+i,100] = (0,0,255)
cv2.imshow('image',img)
cv2.waitKey(0)

(8)tensorflow运算原理

tensorflow的实质是有tensor和计算图graphs组成。tensor是tensorflow基础的一个概念——张量。

本质 tf = tensor + 计算图 tensor数据 op 操作 graphs 计算图 数据的操作

所有的计算图和操作数都是放在session中执行的。tensorflow的运行、操作都是放在session回话中执行的。session是执行的核心。

(9)tensorflow的常量和变量的定义

# opencv的基本的运用
# 学习tensorflow的基本的运算
# 类比一门开发语言，掌握基础语法，api的调用，理解基本的原理
# 基础的数据类型  运算符  路程  字典  元组
import tensorflow as tf

tf.compat.v1.disable_eager_execution()
data1 = tf.constant(2.5)
data3 = tf.constant(2 ,dtype=tf.int32)
data2 = tf.Variable(10,name = 'var')

sess = tf.compat.v1.Session()
# print(data1)
# print(date2)
print(data3)

# 输出的结果为：
# tf.Tensor(2.5, shape=(), dtype=float32)   
# <tf.Variable 'var:0' shape=() dtype=int32, numpy=10>
# Tensor("Const_21:0", shape=(), dtype=int32)   shape()表示的是维度
#  tensor是tensorflow基础的一个概念——张量。
# tf.Tensor就是名字，’Const’是名字。0是索引，表示张量是这个计算中产生的第几个。shape=()是形状，这个是标量所以是空，dtype为数据类型。
# print(sess.run(data1))
# 输出的结果为：2.5
print(sess.run(data3))
# 输出的结果为：2

init = tf.compat.v1.global_variables_initializer()# 变量需要初始化的操作。
sess.run(init)
print(sess.run(data2))
# 输出的结果为：10
sess.close()  # session关闭回话。


# 本质 tf = tensor + 计算图
# tensor数据
# op  操作
# graphs 计算图  数据的操作
# 所有的计算图和操作数都是放在session中执行的。tensorflow的运行、操作都是放在session回话中执行的。
# session是执行的核心。

import tensorflow as tf
tf.compat.v1.disable_eager_execution()
data1 = tf.constant(2,dtype=tf.int32)
data2 = tf.Variable(10,name='var')
print(data1)
print(data2)
init = tf.compat.v1.global_variables_initializer()# 变量的初始化
sess = tf.compat.v1.Session()
'''
sess.run(init)# 注意这个的sess.run()一下变量的初始化的操作。
print(sess.run(data1))
print(sess.run(data2))
'''
# 使用with sess：来写的结果是一样的。和上面的结果是一样的。
with sess:
    sess.run(init)# sess.run()一下变量的初始化的操作
    print(sess.run(data1))
    print(sess.run(data2))
sess.close()

(10)tensorflow的四则运算

掌握以下的四个代码，tensorflow的四则运算就会明白。加减乘除。

import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.constant(2)
# data2 = tf.Variable(5,name = 'var')
dataAdd = tf.add(data1,data2)
dataMul = tf.multiply(data1,data2)
dataDiv = tf.divide(data1,data2)
dataSub = tf.subtract(data1,data2)

tf.compat.v1.disable_eager_execution()

sess = tf.compat.v1.Session()

with sess:
    print(dataAdd)
    print(dataMul)
    print(dataDiv)
    print(dataSub)
    print(sess.run(dataAdd))
    print(sess.run(dataMul))
    print(sess.run(dataDiv))
    print(sess.run(dataSub))

# 输出的结果为：
# Tensor("Add:0", shape=(), dtype=int32)
# Tensor("Mul:0", shape=(), dtype=int32)
# Tensor("truediv:0", shape=(), dtype=float64)
# Tensor("Sub:0", shape=(), dtype=int32)
# 8
# 12
# 3.0
# 4

# 还可以写成下面这种形式：
# with tf.compat.v1.Session() as sess:
#     print(dataAdd)
#     print(dataMul)
#     print(dataDiv)
#     print(dataSub)
#     print(sess.run(dataAdd))
#     print(sess.run(dataMul))
#     print(sess.run(dataDiv))
#     print(sess.run(dataSub))
print('end!') # end!
sess.close()

import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.Variable(2,name = 'var')
dataAdd = tf.add(data1,data2)
dataMul = tf.multiply(data1,data2)
dataDiv = tf.divide(data1,data2)
dataSub = tf.subtract(data1,data2)

tf.compat.v1.disable_eager_execution()
init = tf.compat.v1.global_variables_initializer()

sess = tf.compat.v1.Session()
# sess.run(init)
with sess:
    sess.run(init)
    print(dataAdd)
    print(dataMul)
    print(dataDiv)
    print(dataSub)
    print(sess.run(dataAdd))
    print(sess.run(dataMul))
    print(sess.run(dataDiv))
    print(sess.run(dataSub))
sess.close()

# '''
# Tensor("Add_5:0", shape=(), dtype=int32)
# Tensor("Mul_5:0", shape=(), dtype=int32)
# Tensor("truediv_5:0", shape=(), dtype=float64)
# Tensor("Sub_5:0", shape=(), dtype=int32)
# 8
# 12
# 3.0
# 4
# '''

import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.Variable(2,name = 'var')
dataAdd = tf.add(data1,data2)
dataMul = tf.multiply(data1,data2)
dataDiv = tf.divide(data1,data2)
dataSub = tf.subtract(data1,data2)

dataCopy = tf.compat.v1.assign(data2,dataAdd)# dataAddd - >data2
tf.compat.v1.disable_eager_execution()

init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
# sess.run(init)
with sess:
    sess.run(init)
    print(dataAdd)
    print(dataMul)
    print(dataDiv)
    print(dataSub)
    print(sess.run(dataAdd))
    print(sess.run(dataMul))
    print(sess.run(dataDiv))
    print(sess.run(dataSub))
    print('sess.run(dataCopy)',sess.run(dataCopy)) # 6+2 =8 ->data2 == 8
    print('dataCopy',dataCopy.eval())# 6+8 =14 ->data2 ==14
    print('tf.compat.v1.get_default_session()',tf.compat.v1.get_default_session().run(dataCopy))# 6+14=20 ->data2 == 20
sess.close()

# 输出的结果为：
# Tensor("Add_12:0", shape=(), dtype=int32)
# Tensor("Mul_12:0", shape=(), dtype=int32)
# Tensor("truediv_12:0", shape=(), dtype=float64)
# Tensor("Sub_12:0", shape=(), dtype=int32)
# 8
# 12
# 3.0
# 4
# sess.run(dataCopy) 8
# dataCopy 14
# tf.compat.v1.get_default_session() 20

# placeholder
# import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
data1 = tf.placeholder(tf.float32)
data2 = tf.placeholder(tf.float32)
dataAdd= tf.add(data1,data2)
with tf.Session() as sess:
    print(sess.run(dataAdd,feed_dict={data1:6,data2:2}))
    # 1.dataAdd  2.data数据(feed_dict)，我们需要传入的数据
print('end!')

(11)矩阵基础

矩阵的乘法和加减法：

# 类比 矩阵类比于数组。M行N列的数组[]   内部[] [里面 列数据]  []中括号整体 行数
# [[6,6]] 表示的是一行两列。
import tensorflow as tf
data1 = tf.constant([[6,6]])
data2 = tf.constant([[2],
                    [2]])
data3 = tf.constant([[3,3]])
data4 = tf.constant([[1,2],
                    [3,4],
                    [5,6]])

print(data4.shape)# 维度  输出三行两列的维度(3, 2)

with tf.compat.v1.Session() as sess:
    print(sess.run(data4))# 打印的是整体的内容
    print(sess.run(data4[0])) # 打印某一行
    print(sess.run(data4[:,0])) # M*N 打印的是某一列
    print(sess.run(data4[0,0]))# 打印的是某一行，某一列，这里打印的是第一行第一列
    print(sess.run(data4[0,1])) # 打印的是某一行，某一列。这里打印的是第一行第二列
    
'''
(3, 2)
[[1 2]
 [3 4]
 [5 6]]
 
[1 2]

[1 3 5]

1
2
'''

# 矩阵的运算。矩阵的加法 和 矩阵的乘法
import tensorflow as tf

data1 = tf.constant([[6,6]]) # (1,2)
data2 = tf.constant([[2],[2]]) # (2,1)
data3 = tf.constant([[3,3]])# (1,2)
data4 = tf.constant([[1,2],[3,4],[5,6]]) # (3,2)

# 我们让data1和data2两个矩阵相乘

matMul = tf.matmul(data1,data2)  # 矩阵的乘法运算
matAdd = tf.add(data1,data3) # 矩阵的加法运算
matMul2 = tf.multiply(data1,data2)# 矩阵的另外一种运算，叫做矩阵对应位置相乘

with tf.compat.v1.Session() as sess:
    print(sess.run(matMul))
    print(sess.run(matAdd))
    print(matMul.shape) # (1, 1)
    print(matAdd.shape) # (1, 2)
    
    print(sess.run(matMul2))# 1X2 2X1  = 2X2
    
    print(sess.run([matMul,matAdd]))
sess.close()

# 输出的结果如下所示：
# [[24]]

# [[9 9]]

# (1, 1)

# (1, 2)

# [[12 12]
#  [12 12]]

# [array([[24]]), array([[9, 9]])] 类型都是int型 v

特殊矩阵的初始化

# 特殊矩阵的初始化
import tensorflow as tf

mat0 =  tf.constant([[0,0,0],[0,0,0]])
mat1 = tf.zeros([2,3])
mat2 = tf.ones([3,2])
mat3 = tf.fill([2,3],15)
with tf.compat.v1.Session() as sess:
    print(sess.run(mat0))
    print(sess.run(mat1))
    print(sess.run(mat2))
    print(sess.run(mat3))
# 输出的结果如下：
# [[0 0 0]
#  [0 0 0]]

# [[0. 0. 0.]
#  [0. 0. 0.]]

# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]

# [[15 15 15]
#  [15 15 15]]

import tensorflow as tf

mat1 =  tf.constant([[2],[3],[4]])
mat2 = tf.zeros_like(mat1)

mat3 = tf.linspace(0.0,2.0,11)

mat4 = tf.compat.v1.random_uniform([2,3],-1,2)  # 定义的是一个2行3列的矩阵，矩阵里面的值是-1-2之间的随意一个数。
with tf.compat.v1.Session() as sess:
    print(sess.run(mat1))
    print(sess.run(mat2))
    print(sess.run(mat3))
    print(sess.run(mat4))
# 输出的结果如下所示：
# [[2]
#  [3]
#  [4]]

# [[0]
#  [0]
#  [0]]

# [0.        0.2       0.4       0.6       0.8       1.        1.2
#  1.4       1.6       1.8000001 2.       ]

# [[ 0.2787714   1.8376992   1.7133217 ]
#  [-0.63647985  1.3729846   0.0578804 ]]

(12)numpy模块的使用

首先在我们的Anaconda Navigator (Anaconda3)开发的环境中，选择tensorflow环境，然后下载安装numpy，我们才可以使用numpy模块。

import numpy as np
data1 = np.array([1,2,3,4,5])
print(data1) # [1 2 3 4 5]

data2 = np.array([[1,2],[3,4]])

print(data2)
# 输出的结果为：
# [[1 2]
# [3 4]]
print(data1.shape)
print(data2.shape)
print(data1.shape,data2.shape) # (5,) (2, 2)
# 输出的结果为：
# (5,)
# (2, 2)

# zeros ones
print(np.zeros([2,3]))
print(np.ones([2,2]))
# [[0. 0. 0.]
#  [0. 0. 0.]]

# [[1. 1.]
#  [1. 1.]]

# 改 查
data2[1,0] = 5
print(data2)
# [[1 2]
#  [5 4]]

print(data2[1,1])
# 输出的结果为4.

# 基本运算
data3 = np.ones([2,3])
print(data3*2) # 对应相乘
# [[2. 2. 2.]
#  [2. 2. 2.]]

print(data3/3) # 对应相除
# [[0.33333333 0.33333333 0.33333333]
#  [0.33333333 0.33333333 0.33333333]]

print(data3+2)# 对应相加
# [[3. 3. 3.]
#  [3. 3. 3.]]

print(data3 -2)
# [[-1. -1. -1.]
#  [-1. -1. -1.]]

# 两个矩阵之间的加法和乘法
data4 = np.array([[1,2,3],[4,5,6]])
print(data3 + data4)
# [[2. 3. 4.]
#  [5. 6. 7.]]

print(data3*data4) # 对应元素相乘

# [[1. 2. 3.]
#  [4. 5. 6.]]

(13)matplotlib模块的使用

首先在我们的Anaconda Navigator (Anaconda3)开发的环境中，选择tensorflow环境，然后下载安装matplotlib，我们才可以使用matplotlib模块。

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1,2,3,4,5,6,7,8])
y = np.array([3,5,7,6,2,6,10,15])

# 绘制的是折线图
plt.plot(x,y,'r') # 折线 参数1：x轴的坐标，参数2：y轴的坐标 参数3颜色color
plt.plot(x,y,'g',lw=10)# 参数4：表示线条的宽度。line width

# 折线图  饼状图  柱状图

# 绘制的是柱状图
x = np.array([1,2,3,4,5,6,7,8])
y = np.array([13,25,17,36,21,16,10,15])
plt.bar(x,y,0.5,alpha=1,color='b')
# 参数一：X轴的坐标 参数二：y轴的坐标 参数三：描述的是柱状图每个柱子的占用比例（0.5） 参数四：透明度 （0-1）参数五：颜色color
plt.show()