最近捶索，需要使用python寫腳本來處理圖像，幸虧最初學習的時候董朝，做了詳細的筆記鸠项。我現(xiàn)在只需復習筆記就可以很靈活的使用opencv。特此將我的筆記奉獻出來子姜，供需要的人參考祟绊。
https://www.bilibili.com/video/av69168847?p=1
*******************圖片讀取，展示********************
思路：
引入opencv模塊
調用API實現(xiàn)圖片讀取和展示
調用API暫停程序
代碼實現(xiàn)：
import cv2
img=cv2.imread('name',1)#圖形讀取API，參數(shù)1為圖片文件全名牧抽，參數(shù)2為將圖片按什么類型讀進來（0為灰度嘉熊，1位彩色），API返回一個表示圖片的矩陣扬舒。完成文件的讀取阐肤，文件封裝格式解析（jpg，png）讲坎，文件數(shù)據(jù)解碼孕惜。
文件的封裝（jpg，png等）：
將文件按文件頭和文件數(shù)據(jù)格式進行封裝（不同格式衣赶，這兩部分不同）
此處的文件數(shù)據(jù)诊赊，不是文件的原始數(shù)據(jù)，而是將圖片壓縮編碼后的數(shù)據(jù)（按比例壓縮圖片府瞄，不同的壓縮比對應得到不同大小的圖片碧磅。縮小圖片體積遵馆，方便存儲和傳輸鲸郊，我們一般常見的都是壓縮后的文件，如.JPG等）
文件頭描述的是文件數(shù)據(jù)部分的解碼信息和附加信息
解碼器根據(jù)文件頭的信息將文件數(shù)據(jù)解碼還原成文件原始數(shù)據(jù)
cv2.imshow('ima',img)#圖片展示API货邓，參數(shù)1為展示圖片的窗口名稱秆撮，參數(shù)2為要展示的圖片的矩陣表示（這里的矩陣已經是對圖片解碼后的原圖片數(shù)據(jù)）。完成數(shù)據(jù)加載
cv2.waitKey(0)#程序暫停API换况，只有暫停程序才能顯示圖片（此處參數(shù)為暫停的時間职辨，0為0ms,1000為1000ms.時間用完后，程序會繼續(xù)向下執(zhí)行）
**************圖片的寫入**************************
思路：
引入opencv模塊
調用API實現(xiàn)圖片的讀取功能
調用API實現(xiàn)圖片的寫入功能(其實就是另存為)
代碼實現(xiàn)：
import cv2
img=cv2.imread('name',1)
cv2.imwrite('name2',img)#圖片寫入API戈二，參數(shù)1為寫入圖片的名稱（就是另存為的名稱舒裤，這個名稱是全名，要包含后綴名）觉吭，參數(shù)2為圖片的矩陣表示數(shù)據(jù)
********不同壓縮比的圖片寫入*****************
思路：
引入opencv模塊
調用API實現(xiàn)圖片的讀取功能
調用API實現(xiàn)按照指定壓縮比寫入圖片（分為有損和無損）
代碼實現(xiàn)：
import cv2
img=cv2.imread('name',1)
cv2.imwrite('name2',img腾供，[cv2.IMWRITE_JPEG_QUALITY，0])#參數(shù)3為圖片質量（也就是壓縮比）鲜滩，參數(shù)3的圖片質量范圍為0~100伴鳖，值越高，質量越高徙硅，0時大約縮小10倍榜聂，100時不縮小。一般壓縮十幾倍嗓蘑，圖片質量和原圖差別肉眼還是不容易看出來的须肆。這個壓縮是有損壓縮（也就是以犧牲圖片質量為代價來壓縮圖片）
jpg格式為有損壓縮贴汪，并且無法設置圖片的透明度
cv2.imwrite('name2',img，[cv2.IMWRITE_PNG_COMPRESSION休吠，0])#png格式為無損壓縮扳埂，可以設置圖片的透明度（在修改RGB值進行壓縮時，還可以修改蹄片的透明度,壓縮比范圍0~9瘤礁，這里壓縮比和jpg正好相反阳懂，值越小質量越高，0時代表無壓縮
*************對圖片的像素值進行讀寫***********************
知識補充：
圖片時候一個個小放方塊組成（每一個方塊就是一個像素點）
像素點：在計算機中柜思，每種顏色都可以用RGB三種顏色分量進行合成（比如黃色是由40%紅色岩调，40%綠色，20%的藍色組成）
像素點如何在計算機中存儲：對于每一個像素點來說赡盘，計算機存儲的實際上是RGB三種顏色的值号枕，對一個8位（8bit）顏色深度（這個顏色深度就是RGB每一個顏色分量都有二的八次方這么多個）的圖片來說，RGB每一個顏色的分量范圍為0~255陨享。(對于一個8位顏色深度的RGB圖像來說葱淳，一共有256的三次方種表示方式)
圖片的寬高：比如寬*高為640*480的圖像，表示的是水平方向上有640個像素點抛姑，豎直方向上有480個像素點
圖像的大性薏蕖：比如1.14M=像素點數(shù)*顏色分量數(shù)*顏色深度（bit）
每個像素點除了RGB三個顏色通道為，還可能有一個alpha通道（描繪的就是圖片的透明度）定硝，如PNG圖片
常見的顏色分量除了RGB外,還有一種是BGR(知識將RGB顏色通道順序改變了)
每一個顏色分量成為一種顏色通道
圖片在內存中存儲的坐標系：橫向為x軸代表列數(shù)(寬度)皿桑，縱向為y軸代表行數(shù)（高度）。（x,y）
思路：
引入opencv模塊
調用API實現(xiàn)圖片的讀取功能
利用矩陣原理讀取給定坐標的像素值（以元組形式返回讀取結果蔬啡，元組內三個元素分別代表B藍綠R紅）
利用數(shù)據(jù)結構實現(xiàn)像素的寫入(也是以元組形式寫入像素值诲侮，元組內元素順序為BGR)
調用API展示圖片
調用API暫停程序
代碼實現(xiàn)：
import cv2
img=cv2.imread('name',1)
（B,G,R）=img[100,100]#利用矩陣原理讀取坐標為（100,100）的像素值（以元組形式返回讀取結果，元組內三個元素分別代表B藍綠R紅）
for i in range(100):
img [10+i,100]=(255,0,0)#利用數(shù)據(jù)結構實現(xiàn)像素的寫入(也是以元組形式寫入像素值箱蟆，元組內元素順序為BGR),此處寫入的是標準的藍色B
cv2.imshow('ima',img)
cv2.waitKey(1000)#暫停1000ms沟绪，后程序繼續(xù)向下執(zhí)行
*********tensorflow基本數(shù)據(jù)類型******************
知識補充：
tensorflow相當于一門開發(fā)語言
因此學習tensorflow就要像學習一門開發(fā)語言一樣，掌握它的基礎語法顽腾，API調用
還要掌握圖像近零，深度學習诺核，機器學習等算法原理（這樣才能自己用tensorflow實現(xiàn)這些原理）
開發(fā)語言有共性：
都有基礎數(shù)據(jù)類型抄肖、運算符、流程控制語句
如果是面向對象的語言還會有 字典窖杀、數(shù)組漓摩、元組等等
tensorflow也具有上述開發(fā)語言的共性
tensorflow中的所有操作都必須要使用seession（會話）來執(zhí)行
程序如果運行中出錯，會打印出報錯的日志（我們需要根據(jù)這個打印出的日志來排查問題入客，修改程序）
思路：
引入tensorflow模塊
調用API定義常量
調用API定義變量
打印常量的表示
打印變量的表示
調用API定義一個seession(會話)
調用API在session中運行打印常量的操作
調用API在會話中一次性初始化所有變量（在TensorFlow中管毙，所有變量必須在會話中進行初始化腿椎，否則會報錯）
調用API關閉會話或使用with關鍵字自動關閉會話（從使用with開始代表創(chuàng)建了session會話，with sess:后的代碼運行結束夭咬，走出with啃炸，代表自動關閉了會話）
代碼實現(xiàn)：
import tensorflow as tf#引入tensorflow，并用tf來代表tensorflow
data1=tf.constant(2.5)#調用API定義常量（此處為浮點型類型）卓舵，并以張量形式返回（張量可以理解為一種數(shù)據(jù)形式）
data2=tf.Variable(10,name='var')#調用API定義變量（參數(shù)1為初始化的變量值10南用，參數(shù)2 為變量的名字var），并以張量形式返回
print(data1)#并未打印出常量2.5掏湾，而是但引出一個描述它的張量tensor（參數(shù)1裹虫，參數(shù)2，參數(shù)3）融击，參數(shù)1表示該數(shù)據(jù)為常數(shù)("Const:0")筑公，參數(shù)2表示數(shù)據(jù)的維度(shape())，參數(shù)3代表該數(shù)據(jù)的數(shù)據(jù)類型（這里dtype=float32）
print(data2)#打印出出對數(shù)據(jù)的描述（參數(shù)1尊浪，參數(shù)2匣屡，參數(shù)3），參數(shù)1表示該數(shù)據(jù)為一個變量(tf.Variable 'var:0' )拇涤，參數(shù)2表示數(shù)據(jù)的維度(shape())耸采，參數(shù)3代表該數(shù)據(jù)的數(shù)據(jù)類型（這里dtype=int32_ref）
sess=tf.Session()#調用API實例化一個Session()類
print(sess.run(data1))#調用API，在會話中打印常量（相當于對張量解析后返回解析結果）
data3=tf.constant(2工育，dtype=tf.int32)#調用API定義常量（此處為定點型類型）虾宇，并以張量形式返回（張量可以理解為一種數(shù)據(jù)形式）
init=tf.global_variables_initializer()#調用API，實例化一個用來初始化變量的類（功能室對tensorflow代碼中所有的變量初始化）
sess.run(init)#將初始化變量的類在會話中執(zhí)行
print(sess.run(data2))#調用API在會話中打印變量（之后在初始化變量之后才能打印成功如绸，否則會報錯）
sess.close()#調用API關閉會話
init=tf.global_variables_initializer()
sess=tf.Session()
with sess:
sess.run(init)
print(sess.run(data2))
**********tensorflow代碼運行原理*************************
知識補充
tensorlfow本質上由張量（tensor）和計算圖(graphs)這兩部分組成
變量和常量都是由張量這種數(shù)據(jù)結構來表示(tensor本質代表TensorFlow中的數(shù)據(jù)嘱朽，數(shù)據(jù)可以是1維，也可以是n維)
op(操作)：對tensor的操作（比如對tensor的賦值怔接，tensor之間的四則運算）搪泳，對tensord的操作必須在Seesion會話中進行
op和tensor共同構成了計算圖
tensorflow的本質也可以理解為，在會話（session）中對張量(tensor)進行的一些列操作(op)扼脐。（換句話說岸军，就是在會話中運行計算圖）
session相當于一個tensorflow運行的環(huán)境
sess.tf.Session()
sess.run(data1)#這里把data1放進括號里，相當于把“data1=tf.constant(2.5)”這一系列都放進會話中執(zhí)行瓦侮。run后的括號的內容會被執(zhí)行艰赞。沒有放進括號中的不會被執(zhí)行。
分析tensorflow代碼肚吏，先分析定義了哪些tensor(數(shù)據(jù))方妖，然后在分析session中的計算圖（也就是對tensor的操作）有哪些。這樣就可以很清晰的理解當前的tensorflow代碼（本質就是對tensor的各種操作）
************tensorflow的數(shù)據(jù)運算-常量與常量**********************
思路：
引入tensorflow模塊
調用API定義常量
調用API定義常量
調用API對常量進行+-*/四則運算(運算結果以tensor形式返回)
使用with 語句創(chuàng)建會話運行程序
結束代碼
代碼實現(xiàn)：
import tensorflow as tf
data1=tf.constant(6)
data2=tf.constant(2)
dataAdd=tf.add(data1,data2)#調用API實現(xiàn)兩個常量相加,這里是data1+data2（運算結果以tensor形式返回）
dataMul=tf.multiply(data1,data2)#調用API實現(xiàn)對兩個常量相乘,這里是data1*data2（運算結果以tensor形式返回）
dataSub=tf.subtract(data1,data2)#調用API實現(xiàn)對兩個常量的減法罚攀，這里是data1-data2(運算結果以tensor形式返回)
dataDiv=tf.divide(data1,data2)#調用API實現(xiàn)對兩個常量的除法党觅，這里是data1/data2(運算結果以tensor形式返回)
with tf.Session() as sess:#使用with 語句簡化會話創(chuàng)建
print(sess.run(dataAdd))
print(sess.run(dataMul))
print(sess.run(dataSub))
print(sess.run(dataDiv))
print('end!')#代表代碼的結束
************tensorflow的數(shù)據(jù)運算-常量與變量**********************
思路：
引入tensorflow模塊
調用API定義常量
調用API定義變量
調用API對常量進行+-*/四則運算(運算結果以tensor形式返回)
一次性初始化所有變量
使用with 語句創(chuàng)建會話運行程序
結束代碼
代碼實現(xiàn)：
import tensorflow as tf
data1=tf.constant(6)
data2=tf.Variable(2)
dataAdd=tf.add(data1,data2)#調用API實現(xiàn)兩個常量相加,這里是data1+data2（運算結果以tensor形式返回）
dataMul=tf.multiply(data1,data2)#調用API實現(xiàn)對兩個常量相乘,這里是data1*data2（運算結果以tensor形式返回）
dataSub=tf.subtract(data1,data2)#調用API實現(xiàn)對兩個常量的減法雌澄，這里是data1-data2(運算結果以tensor形式返回)
dataDiv=tf.divide(data1,data2)#調用API實現(xiàn)對兩個常量的除法，這里是data1/data2(運算結果以tensor形式返回)
init=tf.global_variables_initializer()
with tf.Session() as sess:#使用with 語句簡化會話創(chuàng)建
sess.run(init)
print(sess.run(dataAdd))
print(sess.run(dataMul))
print(sess.run(dataSub))
print(sess.run(dataDiv))
print('end!')#代表代碼的結束
************tensorflow的數(shù)據(jù)運算-數(shù)據(jù)拷貝*********************
知識補充:
tensorflow中程序在會話中運行的方式有兩種：
一種是調用run方法:sess.run(程序)
一種是調用eval方法：程序.eval()
兩種方法本質是一樣的杯瞻，eval方法其實是獲取了一個默認會話的镐牺，并調用默認會話的run方法
程序.eval()=tf.get_default_session().run()程序
思路：
引入tensorflow模塊
調用API定義常量
調用API定義變量
調用API對常量進行+-*/四則運算(運算結果以tensor形式返回)
調用API拷貝數(shù)據(jù)
一次性初始化所有變量
使用with 語句創(chuàng)建會話運行程序
結束代碼
代碼實現(xiàn)：
import tensorflow as tf
data1=tf.constant(6)
data2=tf.Variable(2)
dataAdd=tf.add(data1,data2)#調用API實現(xiàn)兩個常量相加,這里是data1+data2（運算結果以tensor形式返回）
dataCopy=tf.assign(data2,dataAdd)#調用API完成數(shù)據(jù)拷貝（將參數(shù)2的數(shù)據(jù)拷貝到參數(shù)1,同時將參數(shù)1的值以tensor形式返回），這里是將dataAdd數(shù)據(jù)拷貝到data2(其實就是賦值)
dataMul=tf.multiply(data1,data2)#調用API實現(xiàn)對兩個常量相乘,這里是data1*data2（運算結果以tensor形式返回）
dataSub=tf.subtract(data1,data2)#調用API實現(xiàn)對兩個常量的減法魁莉，這里是data1-data2(運算結果以tensor形式返回)
dataDiv=tf.divide(data1,data2)#調用API實現(xiàn)對兩個常量的除法任柜，這里是data1/data2(運算結果以tensor形式返回)
init=tf.global_variables_initializer()
with tf.Session() as sess:#使用with 語句簡化會話創(chuàng)建
sess.run(init)
print(sess.run(dataAdd))
print(sess.run(dataMul))
print(sess.run(dataSub))
print(sess.run(dataDiv))
print(sess.run(dataCopy))
print('dataCopy.eval()',dataCopy.eval())
print('tf.get_default_session.run(dataCopy)',tf.get_default_session().run(dataCopy))
print('end!')#代表代碼的結束
*************tensorflow-placehold功能*******************
知識補充：
數(shù)據(jù)可以在初始化的時候定義好，后續(xù)運算的時候直接用
數(shù)據(jù)也可以在運算的過程中實時插入進去（使用placehold函數(shù)來實現(xiàn)這種操作）
思路：
引入tensorflow
調用API初始化數(shù)據(jù)
調用API實現(xiàn)對數(shù)據(jù)的加法
創(chuàng)建會話
在會話中運行計算圖的同時沛厨，輸入數(shù)據(jù)
輸出結束
代碼實現(xiàn)：
import tensorflow as tf
data1=tf.placeholder(tf.float32)#調用API初始化數(shù)據(jù)宙地，這里并未對數(shù)據(jù)進行具體定義，只是定義了數(shù)據(jù)的類型為float32（就是括號里的參數(shù)）
data2=tf.placeholder(tf.float32)
dataAdd=tf.add(data1,data2)
with tf.Session() as sess:
print(sess.run(dataAdd,feed_dcit={data1:6,data2:2}))#調用API,在會話中運行計算圖時,對數(shù)據(jù)進行賦值逆皮，這里用的是feed_dict={參數(shù)1：data宅粥，參數(shù)2：data}語法（這里也叫喂數(shù)據(jù)，因為feed中文意思是喂电谣，dict是數(shù)據(jù)的縮寫）
print('end')
*************tensorflow矩陣原理*****************
知識補充：
矩陣其實就是一個多維數(shù)組（m行n列的數(shù)組）
矩陣下標是從0開始的秽梅，3行2列的矩陣其實行從0~2（m的范圍），和列0~1（n的范圍）
矩陣最外面有[](這是矩陣的基礎語法剿牺，這個[]是一定要有的)
矩陣的內部全部是由一個個的[列數(shù)據(jù),列數(shù)據(jù)]組成（每一個[列數(shù)據(jù)]整體表示一行企垦，里面的數(shù)據(jù)表示的是列數(shù)據(jù)）
按照矩陣語法定義一個1行2列的矩陣：
先把最外層中括號寫上：[]
行數(shù)是一行，那么內部的中括號就只有一個：[[]]
列數(shù)是2晒来，則內部的每一個[]里有兩個數(shù)據(jù)：[[0,0]]
思路：
引入tensorflow
調用API定義矩陣
打印矩陣維度
創(chuàng)建會話
打印矩陣
代碼實現(xiàn)：
import tensorflow as tf
data1=tf.constant([[6,6]])#調用API定義一個矩陣（這里是一行兩列的矩陣）
data2=tf.constant([[2],[2]])#調用API定義一個矩陣（這里是兩行一列的矩陣）
data3=tf.constant([[3,3]])
data4=tf.constant([[1,2],[3,4],[5,6]])#調用API定義一個矩陣（這里是三行兩列的矩陣）
print(data4.shape)#使用矩陣的shape屬性钞诡，打印矩陣的維度
with tf.Session() as sess:
print(sess.run(data4))#打印整個矩陣
print(sess.run(data4[0]))#以列表的心事打印行，這里是打印第0行（矩陣[n],這個語法是用來打印第n行湃崩，[]中只有一個元素荧降，這個元素代表的就是第幾行）
print(sess.run(data4[:,0]))#以列表的形式打印列，這里是打印第0列（矩陣[:,n],這個語法是用來打印第n列攒读，[]中有兩個元素朵诫，第一個元素代表行，這里沒給出就是代表打印所有行薄扁，第二個元素代表列）
print(sess.run(data4[0,0]))#打印第0行剪返，第0列的元素
*************tensorflow矩陣運算*****************
知識補充：
矩陣加法（1種），矩陣進行加法運算時邓梅，矩陣規(guī)模必須相同（就是行數(shù)和列數(shù)必須相同）脱盲，矩陣加法其實就是對應元素相加。
矩陣乘法（2種）震放，
第一種宾毒，矩陣乘法運算時驼修，第一個矩陣的列必須和第二個矩陣的行數(shù)相同才可以進行乘法運算（第一個矩陣的行與第二個矩陣的列對應元素相乘殿遂，并將相乘的結果相加得到一個值作為乘法運算得到的矩陣的元素，第一個矩陣的行位置和第二個矩陣的列位置就是得到的這個元素的行標和列標）
第二種，就是矩陣對應元素相乘骡湖，最終結果的位數(shù)是兩個矩陣最大維數(shù)的合成
一次性打印多個結果：
使用print(sess.run([參數(shù)1榛臼，參數(shù)2，參數(shù)3]))這種語法恩静，一次性打印多個結果
思路：
引入tensorflow
調用API定義矩陣
調用API完成第一種矩陣乘法運算焕毫，結果以tensor形式返回
調用API完成第二種矩陣乘法運算，結果以tensor形式返回
調用API完成矩陣加法運算驶乾，結果以tensor形式返回
創(chuàng)建會話
運行計算圖
代碼實現(xiàn)：
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]])
matMul=tf.matmul(data1,data2)#調用API完成第一種矩陣乘法運算邑飒，結果以tensor形式返回。此處乘法的結果為1行1列
matMul2=tf.multiply(data1,data2)#調用API完成第二種矩陣乘法運算级乐，結果以tensor形式返回疙咸。此處乘法的結果為2行2列
matAdd=tf.add(data1,data3)#調用API完成矩陣加法運算，結果以tensor形式返回风科。此處加法的結果為1行2列
with tf.Session() as sess:
print(sess.run(matMul))
print(sess.run(matMul2))
print(sess.run(matAdd))
print(sess.run([matMul,matMul2,matAdd]))#使用print(sess.run([參數(shù)1撒轮，參數(shù)2，參數(shù)3]))這種語法贼穆，一次性打印多個結果
*************tensorflow特殊矩陣的初始化*****************
知識補充：
定一個空矩陣
可以按照普通定義矩陣方式進行定義
也可以調用tf.zeros([行數(shù)题山，列數(shù)])這個API進行定義
定義一個全1矩陣
可以按照普通定義矩陣方式進行定義
也可以調用tf.ones([行數(shù)，列數(shù)])這個API進行定義
定義一個全n矩陣(也叫填充矩陣)
可以按照普通定義矩陣方式進行定義
也可以調用tf.fill([行數(shù)故痊，列數(shù)],n)API進行定義
拷貝現(xiàn)有矩陣規(guī)模顶瞳，定義空矩陣：
可以按照普通定義矩陣方式進行定義
也可以調用tf.zeros_like(目標局陣)進行定義
將一個范圍內的數(shù)據(jù)等分后作為矩陣元素：
可以按照普通定義來進行定義
也可以調用tf.linspace(起始值，終止值愕秫，等分數(shù))API來進行定義
隨機矩陣序列：
定一個給定規(guī)模的矩陣浊仆，并且這個矩陣的元素是在一個范圍內的隨機值
調用tf.random_uniform([行數(shù)，列數(shù)]豫领，其實值抡柿，終止值)API來定義
思路：
引入tensorflow
調用API定義矩陣
創(chuàng)建會話
打印矩陣
代碼實現(xiàn)：
import tensorflow as tf
mat0=tf.constant([[0,0,0],[0,0,0]])
mat1=tf.zeros([2,3])#調用tf.zeros([行數(shù)，列數(shù)])API,生成全0矩陣
mat2=tf.ones([3,2])#調用tf.ones([行數(shù)等恐，列數(shù)])API洲劣，生成全1矩陣
mat3=tf.fill([2,3],15)#調用tf.fill([行數(shù)，列數(shù)],n)API,生成全n矩陣课蔬，這里n=15
mat4=tf.zeros_like(mat3)#調用tf.zeros_like(目標局陣),定義一個和目標局陣規(guī)模相同的全0矩陣囱稽，這里目標局陣是mat3
mat5=tf.linspace(0.0,2.0,11)#調用tf.linspace(起始值，終止值二跋，元素個數(shù))API來進行定義战惊，這里是將0~2范圍內的數(shù)等分為10份（也就是最后矩陣有11個元素）
mat6=tf.random_uniform([2,3],-1,2)#調用tf.random_uniform([行數(shù)，列數(shù)]扎即，其實值吞获，終止值)API來定義矩陣况凉，這里是定義一個2行3列的矩陣，矩陣元素為-1~2之間的隨機值
with tf.Session() as sess:
print(sess.run(mat0))
print(sess.run(mat1))
print(sess.run(mat2))
print(sess.run(mat3))
print(sess.run(mat4))
print(sess.run(mat5))
print(sess.run(mat6))
******************numpy****************
知識補充：
矩陣的基本操作和數(shù)據(jù)庫類似（都是CRUD增刪改查）
思路：
引入numpy模塊
調用API定義一個矩陣
打印矩陣
打印矩陣維度
調用API,直接打印特殊矩陣
矩陣的修改和查詢
實現(xiàn)矩陣和常數(shù)之間的基本運算
實現(xiàn)矩陣和矩陣之間的基本運算
代碼實現(xiàn)：
import numpy as np
data1=np.array([1,2,3,4,5])#調用API各拷，array()生成一個矩陣刁绒，并將矩陣以nDarry類型返回
data2=np.array([[1,2],[3,4]])#調用API，array()生成一個矩陣烤黍，并將矩陣以nDarry類型返回
print(data1)
print(data2)
print(data1.shape)#利用nDarry類型矩陣的shape屬性知市，打印矩陣維度（以元組形式返回矩陣維度）
print(data2.shape)#利用nDarry類型矩陣的shape屬性，打印矩陣維度（以元組形式返回矩陣維度）
print(np.zeros([2,3]),np.ones([2,2]))#調用API,直接打印特殊矩陣(這里打印了空矩陣和全1矩陣)
data2[1,0]=5#利用矩陣性質對矩陣元素進行修改速蕊，其實就是賦值（這里是將1行0列的位置元素賦值為5）
print(data2)
print(data2[1,1])#利用矩陣性質查詢矩陣元素（這里是查詢位于第1行第1列的矩陣元素）
data3=np.ones([2,3])
print(data3*2)#實現(xiàn)矩陣乘法（矩陣乘以一個常數(shù)）
print(data3/3)#實現(xiàn)矩陣除法（矩陣除以一個常數(shù)）
print(data3+2)#實現(xiàn)矩陣加法（矩陣加上一個常數(shù)）
data4=np.array([[1,2,3],[4,5,6]])
print(data3+data4)#實現(xiàn)兩個矩陣相加(兩個矩陣對應元素相加)
print(data3*data4)#相乘實現(xiàn)兩個矩陣相加(兩個矩陣對應元素相乘)
***********matplotlib模塊******************
知識補充：
常用到的三大圖表（折線嫂丙，餅狀，柱狀）
思路：
引入numpy模塊
引入matplotlib模塊的繪圖方法pyplot
利用矩陣定義x軸坐標和y軸坐標
調用API繪制折線圖
調用API繪制柱狀圖
顯示圖
代碼實現(xiàn)：
import numpy as np
import matplotlib.pyplot as plt
x=np.array([1,2,3,4,5,6,7,8])#定義即將繪制的圖的x軸坐標矩陣
y=np.array([1,5,7,6,2,7,10,15])#定義即將繪制的圖的y軸坐標矩陣
plt.plot(x,y,'r')#調用API繪制折線圖,這里是調用plot(x軸坐標矩陣规哲，y軸坐標矩陣奢入，顏色)API來進行繪制折線圖
plt.plot(x,y,'g',lw=10)#調用API繪制折線圖,這里是調用plot(x軸坐標矩陣，y軸坐標矩陣媳叨，顏色,線條寬度)API來進行繪制折線圖
x=np.array([1,2,3,4,5,6,7,8])#定義即將繪制的圖的x軸坐標矩陣
y=np.array([13,25,17,36,21,16,10,15])#定義即將繪制的圖的y軸坐標矩陣
plt.bar(x,y,0.5,alpha=1,color='b')#調用API繪制柱狀圖,這里是調用bar(x軸坐標矩陣腥光，y軸坐標矩陣,柱寬度比例,透明度(這個屬性只有PNG圖片有),顏色)API來進行繪制柱狀圖
plt.show()
**********股票實例***********
知識補充：
思路：
導入tensorflow、numpy糊秆、matplotlib模塊
定義x軸和y軸
調用API定義一個繪圖
利用循環(huán)進行數(shù)據(jù)裝載武福，并繪制柱狀圖
顯示當前圖
代碼實現(xiàn)：
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
date=np.linspace(1,15,15)#定義x軸坐標矩陣（這里是日期）
endPrice=np.array([2511.90,2538.26,2510.68,2591.66,2732.98,2701.69,2701.29,2678.67,2726.50,2681.50,2739.17,2715.07,2823.58,2864.90,2919.08])#定義y軸坐標矩陣（這里是收盤價格）
beginPrice=np.array([2438.71,2500.88,2534.95,2512.52,2594.04,2743.26,2697.47,2695.24,2678.23,2722.13,2674.93,2744.13,2717.46,2832.73,2877.40])#定義y軸坐標矩陣（這里是開盤價格）
print(date)
plt.figure()#調用API定義一個繪圖
for i in range(15):
? ? dateOne=np.zeros([2])
? ? dateOne[0]=i
? ? dateOne[1]=i
? ? priceOne=np.zeros([2])
? ? priceOne[0]=beginPrice[i]
? ? priceOne[1]=endPrice[i]
? ? if endPrice[i]>beginPrice[i]:
? ? ? ? plt.plot(dateOne,priceOne,'r',lw=8)
? ? else:
? ? ? ? plt.plot(dateOne,priceOne,'g',lw=8)
plt.show()
*********實現(xiàn)神經網絡******************
知識補充：
神經網絡分為三層
輸入層（A,就是一個輸入矩陣），輸入層功能就是把數(shù)據(jù)傳遞個隱藏層
隱藏層（B,也是由一個個的矩陣組成）痘番，數(shù)據(jù)經隱藏層計算之后捉片，計算結果傳遞給輸出層
輸出層（C,就是一個輸出矩陣），輸出層就是保存顯示最后結果
通過輸入天數(shù)汞舱，輸出每天對應的股價（收盤價格）
用數(shù)學公式將神經網絡不同層之間進行連接：
A*w1+b1=B
B*w2+b2=C
A：輸入矩陣（15*1）
B：隱藏層矩陣（15*10）
C：輸出矩陣（15*1）
w1:權重矩陣（1*10）
b1:偏移矩陣（1*10）
w2:_______(10*1)
b2:________(15*1)
就是輸入天數(shù)矩陣A伍纫，通過利用w1,b1,w2,b2,最終得到輸出天數(shù)矩陣C
第1次循環(huán)，輸入日期A,初始化w1,w2,,b1,b2為0.1昂芜，0.1莹规，0.2，0.3泌神，計算出第一天的股價C1良漱。然后將已知的股價C10-C1的得到預測股價與真實股價的差值D1
第二次循環(huán)，利用梯度下降法（一個API欢际，這個API的功能是為了使當前的預測值和真實值得差距D1減小母市。這個API是通過修改w1,w2,b1,b2,的值來逐漸是當前預測值和真實值差距D1減小。因此這個API會給出更新后的w1,w2,b1,b2為0.11,0.99.0,22,0.34损趋，然后利用更新后的w1,w2,b1,b2患久，重復第一次的循環(huán)，計算出新的C1,然后繼續(xù)與C10做差更新D1）
然后不斷循環(huán)直到終止
終止條件可以定義循環(huán)多少次進行終止（可自己定義）
終止條件也可以通過控制D1來進行終止（比如說定義C1,和C10差異在2%以內則終止循環(huán)）
循環(huán)終止之后會得到一個最終的w1,w2,b1,b2（這就是神經網絡最重要的參數(shù)，得到這些參數(shù)的模型蒋失，就叫做訓練好的模型）返帕，然后利用這些最終的參數(shù)就可以輸入未來的日期進行預測未來的股價。
其實w,b在神經網絡圖上表現(xiàn)出來就是節(jié)點之間的連線（節(jié)點其實就相當于矩陣）高镐，這樣得到最終的w,b就相當于確定了節(jié)點的連線溉旋，這樣任意給定一個輸入就可以根據(jù)這些線來計算出隱藏層節(jié)點（結果）和輸出層節(jié)點（結果）
所以神經網絡最根本的實質就是來求w,b（就是來求這些節(jié)點之間的線）
講述輸入神經網絡之前畸冲，為了計算方便嫉髓，需要對數(shù)據(jù)預處理（歸一化）
激勵函數(shù)其實就是對當前計算結果進行映射變成另外一個值
思路：
導入tensorflow、numpy邑闲、matplotlib模塊
定義x軸和y軸
調用API定義一個繪圖
利用循環(huán)進行數(shù)據(jù)裝載算行，并繪制柱狀圖
對輸入數(shù)據(jù)進行歸一化
初始化權值
初始化偏移量
計算出隱藏層矩陣
利用激勵函數(shù)處理隱藏層矩陣
初始化權值
初始化偏移量
計算出輸出層矩陣
利用激勵函數(shù)處理輸出層矩陣
調用API計算預測結果和實際結果的差異（損失值）
利用梯度下降法不斷迭代，調整權值和偏移量苫耸，使損失值不斷減小
創(chuàng)建會話
一次性初始化所有變量
運行計算圖（這個過程也叫作訓練模型）
定義迭代終止條件（滿足條件時停止迭代州邢，完成訓練）
運行迭代程序（同時輸入參數(shù)）
對模型進行測試
并將測試結果進行還原（就是去歸一化），然后與真實值進行比較
繪制預測結果柱狀圖
顯示圖
代碼實現(xiàn)：
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
date=np.linspace(1,15,15)#定義x軸坐標矩陣（這里是日期）
endPrice=np.array([2511.90,2538.26,2510.68,2591.66,2732.98,2701.69,2701.29,2678.67,2726.50,2681.50,2739.17,2715.07,2823.58,2864.90,2919.08])#定義y軸坐標矩陣（這里是收盤價格）
beginPrice=np.array([2438.71,2500.88,2534.95,2512.52,2594.04,2743.26,2697.47,2695.24,2678.23,2722.13,2674.93,2744.13,2717.46,2832.73,2877.40])#定義y軸坐標矩陣（這里是開盤價格）
print(date)
plt.figure()#調用API定義一個繪圖
for i in range(15):
? ? dateOne=np.zeros([2])
? ? dateOne[0]=i
? ? dateOne[1]=i
? ? priceOne=np.zeros([2])
? ? priceOne[0]=beginPrice[i]
? ? priceOne[1]=endPrice[i]
? ? if endPrice[i]>beginPrice[i]:
? ? ? ? plt.plot(dateOne,priceOne,'r',lw=8)
? ? else:
? ? ? ? plt.plot(dateOne,priceOne,'g',lw=8)
dateNormal=np.zeros([15,1])
priceNormal=np.zeros([15,1])
for i in range(15):
? ? dateNormal[i,0]=i/14#歸一化輸入層矩陣
? ? priceNormal[i,0]=endPrice[i]/3000.0#歸一化輸入層矩陣
x=tf.placeholder(tf.float32,[None,1])
y=tf.placeholder(tf.float32,[None,1])
w1=tf.Variable(tf.random_uniform([1,10],0,1))#隨機初始化權重
b1=tf.Variable(tf.zeros([1,10]))#初始化偏移量
wb1=tf.matmul(x,w1)+b1#根據(jù)輸入層矩陣褪子、權值量淌，偏移量，計算出隱藏層矩陣
layer1=tf.nn.relu(wb1)#利用激勵函數(shù)對隱藏層局陣進行映射嫌褪，生成新的隱藏層矩陣
w2=tf.Variable(tf.random_uniform([10,1],0,1))#隨機初始化權重
b2=tf.Variable(tf.zeros([15,1]))#初始化偏移量
wb2=tf.matmul(layer1,w2)+b2#根據(jù)隱藏層矩陣呀枢、權值，偏移量笼痛，計算出輸出層矩陣
layer2=tf.nn.relu(wb2)#利用激勵函數(shù)對輸出層局陣進行映射裙秋，生成新的輸出層矩陣
loss=tf.reduce_mean(tf.square(y-layer2))#調用API計算預測結果和實際結果的差異
#。這里使用square(實際值矩陣-預測值矩陣)API缨伊，對實際值和預測值的差進行開方摘刑。
#然后再使用reduce_mean（矩陣）API,對得到的差值矩陣取平均值。
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)#利用梯度下降法不斷迭代刻坊，調整權值和偏移量枷恕，使損失值不斷減小
with tf.Session() as sess:
? ? sess.run(tf.global_variables_initializer())
? ? for i in range(10000):#定義迭代終止條件（滿足條件時停止迭代，完成訓練）
? ? ? ? sess.run(train_step,feed_dict={x:dateNormal,y:priceNormal})#運行迭代程序（同時輸入參數(shù)）
? ? pred=sess.run(layer2,feed_dict={x:dateNormal})#對模型進行測試
? ? predPrice=np.zeros([15,1])
? ? for i in range(15):
? ? ? ? predPrice[i,0]=(pred*3000)[i,0]#并將測試結果進行還原（就是去歸一化）谭胚，然后與真實值進行比較
? ? plt.plot(date,predPrice,'b',lw=1)#繪制預測結果柱狀圖
plt.show()
**********圖像幾何變換*************
知識補充：
圖像的幾何變換是圖像處理中非郴钭穑基礎的一步。
圖像的幾何變換很少直接應用在工程中漏益，常用于實現(xiàn)工程前圖像預處理蛹锰。
只要涉及到圖像處理和計算機視覺都會用到圖像的幾何變換（圖像的幾何變換是計算機視覺的基礎）。
常用的圖像幾何變換绰疤，圖形等比例縮放
后續(xù)會用Hog+SVM實現(xiàn)一個目標檢測算法铜犬，但是目標檢測第一步就是圖像樣本的準備，所有的樣本搜集好之后，都要運用圖像幾何變換變?yōu)橄嗤叽绲拇笮⊙⒒＃ㄆ鋵嵕褪菍D像等比例縮放或者裁剪敛劝，得到相同規(guī)格大小的圖片作為訓練學習的樣本）
圖像的放射變換（也叫投射變換），其實就是將圖片從一中形狀投射成另一種形狀（比如車幅系統(tǒng)中的車道檢測算法纷宇，一般攝取的車道是梯形夸盟，我們需要運用放射變換，將梯形的車道投射程正方形的車道）
圖像幾何變換是高級計算機視覺的基礎和前提
其他常用的圖像幾何變換像捶，圖像位移上陕，圖像鏡像，圖像剪切拓春，（還有上面提到的释簿，圖像縮放，圖像放射變化）
圖像縮放硼莽，其實就是改變圖像的寬和高
包括圖像放大和圖像縮小
具體又可分為圖片等比例縮放和圖片非等比例縮放
四種常用的圖像縮放算法：最近鄰域插值算法庶溶、雙線性插值算法（默認情況下使用這一種）、像素關系重采樣懂鸵、立方插值
圖片剪切偏螺，其實就是已知圖片矩陣中的一塊數(shù)據(jù)，根據(jù)這個已知圖像塊的數(shù)據(jù)把它從整個圖像矩陣中單獨剪切出來（本質其實就是對矩陣的操作）
圖片的位移,就是通過矩陣運算匆光，將圖片的位置在視圖中整體移動
圖片的鏡像套像，其實就是將原圖像矩陣倒序繪制一次，然后倒序繪制的新矩陣和原圖像矩陣拼接成一個兩倍大的矩陣
其實不論位移殴穴，還是旋轉凉夯、縮放，都可以通過圖像放射變換來實現(xiàn)
圖像的幾何變換的本質就是對圖像矩陣的操作
思路：
引入opencv模塊
加載圖片
獲取圖片信息（寬采幌、高）
定義縮放后的圖片尺寸
調用API完成圖片的縮放
顯示縮放結果
暫停
代碼實現(xiàn)：
import cv2
img=cv2.imread('1.jpg',1)#讀入圖片（這里的img其實就是一個矩陣）
imgInfo=img.shape#獲取矩陣的行數(shù)（就是圖片的高度）劲够，矩陣的列數(shù)（就是圖片的寬度）,通道數(shù)（圖片的顏色組成方式）
print(imgInfo)
height=imgInfo[0]#圖像的高
widht=imgInfo[1]#圖像的寬
mode=imgInfo[2]#圖像顏色組成方式（此處為3，表示一個圖像的像素點實際上是由三個基本顏色組成）
dstHeight=int(height*0.5)#定義縮放后的圖片高度
dstWidth=int(width*0.5)#定義縮放后的圖片寬度
dst=cv2.resize(img,(dstHeight,dstWidth))#調用API對圖片進行縮放操作休傍，這里使用cv2.resize(原圖矩陣,(縮放后的高度征绎，縮放后的寬度))這個API，返回一個縮放后的圖片矩陣
cv2.imshow('image',dst)
cv2.waitKey(0)
**********最近鄰域插值法磨取、雙線性插值法*************************
知識補充：
在將原圖縮放成目標圖片時人柿。目標圖片上的每一個點都可以來自原圖像（如何通過計算的方式找到這些點）
如果已知目標圖片的點坐標（x,y），計算出它來自與原圖片的那個點（x0,y0）
x0=x*(原圖行數(shù)/目標圖片行數(shù))
y0=y*(原圖列數(shù)/目標圖片列數(shù))
當計算出來的x0,y0是浮點數(shù)時忙厌，進行取整即可（四舍五入凫岖，去距離當前浮點數(shù)最近的整數(shù)，這就叫做最近鄰域插值法）
當計算出來的x0,y0是浮點數(shù)時逢净，使用周邊四個像素點與權重進行線性運算來表示點（x0,y0）(這就是雙線性插值法)哥放。具體如下圖
這里計算出來的x0=15.3,y0=22.3
A1=20%(15,22)+80%(16,22)
A2=20%(15,23)+80%(16,23)
(x0,y0)=A1*30%+A2*70%
B1=30%(15,22)+70%(15,23)
B2=30%(15622)+70%(16,23)
(x0,y0)=B1*20%+B2*80%
上面兩種計算方式（一種是用A1,A2歼指；一種使用B1,B2表示）都可以，任選一種表示方式即可
圖形縮放實現(xiàn)方式
可以直接調用API,cv2.resize()
也可以根據(jù)幾種插值法的算法原理甥雕，編寫源碼實現(xiàn)
對每一個編程和算法的知識點踩身，分這三步（現(xiàn)成的API,經典算法原理，算法原理的代碼實現(xiàn)）社露，就可以掌握的十分透徹
大多課程挟阻，都是只講了API的調用和算法原理，而對算法原理的代碼實現(xiàn)峭弟，需要我們自己課下實現(xiàn)和反復的練習附鸽，才能徹底吃透這一個知識點或算法
思路：
引入opencv
引入numpy模塊
獲取圖片信息
定義縮放后的目標圖片的高和寬
創(chuàng)建空白模板（大小與縮放后的目標圖像相同）
計算空白模板的每一個像素在原圖的坐標，并從原圖中復制對應像素點空白模板(這就完成了對圖片的縮放孟害，得到了目標圖片)
顯示縮放后的圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)#讀入圖片（這里的img其實就是一個矩陣）
imgInfo=img.shape#獲取矩陣的行數(shù)（就是圖片的高度）拒炎，矩陣的列數(shù)（就是圖片的寬度）,通道數(shù)（圖片的顏色組成方式）
print(imgInfo)
height=imgInfo[0]#圖像的高
width=imgInfo[1]#圖像的寬
mode=imgInfo[2]#圖像顏色組成方式（此處為3挪拟，表示一個圖像的像素點實際上是由三個基本顏色組成）
dstHeight=int(height*0.5)#定義縮放后的圖片高度
dstWidth=int(width*0.5)#定義縮放后的圖片寬度
dstImage=np.zeros((dstHeight,dstWidth,3),np.uint8)#調用API按照目標圖片尺寸和信息創(chuàng)建空白模板挨务，這里使用了np.zeros((目標圖片高，目標圖片寬玉组，目標圖片通道數(shù))谎柄，目標圖片每個像素的數(shù)據(jù)類型)，這里np.uint8這個數(shù)據(jù)類型的范圍是0-255
for i in range(0,dstHeight):
for j in range(0,dstWidth):
iNew=int(i*(height*1.0/dstHeight))#利用公式計算出惯雳，與目標圖片該點對應的原圖片中點的坐標x朝巫。這里乘以1.0是為了類型轉換（轉換為浮點型）
jNew=int(j*(width*1.0/dstWidth))#利用公式計算出，與目標圖片該點對應的原圖片中點的坐標y石景。這里乘以1.0是為了類型轉換（轉換為浮點型）
dstImage[i,j]=img[iNew,jNew]#根據(jù)計算得出的坐標劈猿，將原圖片中的像素點復制到目標圖片中。（以此完成圖像的縮放）
cv2.imshow('dst',dstImage)
cv2.waitKey(0)
*************************圖片的剪切******************************
知識點補充：
圖片坐標系如圖
x軸表示寬度或者叫列信息（向右為+）潮孽，y軸表示高度或者叫行信息（向下為+）
左上角為（0,0）點
實現(xiàn)圖像剪切時揪荣，首先要確定剪切出來的目標圖片在原始圖片中的位置（也就是目標圖片的左上角的原點在原圖中的坐標）。然后根據(jù)坐標和目標圖片的尺寸來進行剪切（從原圖剪切得到目標圖片）
思路：
引入opencv
讀取圖片信息
實現(xiàn)圖片的剪切
顯示剪切出來的圖片
暫停
代碼實現(xiàn)：
import cv2
img=cv2.imread('1.jpg',1)
imgInfo=img.shape
dst= img[100:200,100:300]#使用 原圖矩陣[剪切圖片在原圖中的x軸范圍往史，剪切圖片在原圖中的y軸范圍] 來得到目標矩陣（剪切出來的圖像矩陣）
cv2.imshow('src',dst)
cv2.waitKey(0)
***************************圖片位移*************************
知識補充：
可以用現(xiàn)成API實現(xiàn)圖片位移
原圖矩陣為C(2*1)=[[x],[y]]
位移矩陣為D(2*3)=[[1,0,100],[0,1,200]]
將D拆分成兩個矩陣A(2*2)=[[1,0],[0,1]],B(2*1)=[[100],[200]]
通過公式A*C+B運算得到位移后的圖片矩陣E
[[1,0],[0,1]]*[[x],[y]]+[[100],[200]]=
[[1*x,0*y],[0*x,1*y]]+[[100],[200]]=
[[x+100],[y+200]]
至此就實現(xiàn)了對圖像的位移
也可以根據(jù)圖片位移的算法原理仗颈，編寫源碼進行實現(xiàn)
對每個像素點進行相同的位移就可得到對整個圖像位移后的目標圖像
其實就是將原圖的每個像素點按照定義的位移投影到空白圖像上的新的坐標點上
本質就是計算與在空白圖像上的像素點坐標（該像素點與原圖像素點相對應）
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬，高）
定義位移矩陣（通過將原圖與該矩陣進行四則運算實現(xiàn)圖像的位移）
調用API椎例，通過將原矩陣按照定義矩陣進行映射得到位移矩陣
顯示位移圖片
暫停
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬挨决，高）
定義空白圖像矩陣
根據(jù)圖像位移的算法原理利用矩陣計算來實現(xiàn)圖像的位移
顯示位移后的圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
matShift=np.float([[1,0,100],[0,1,200]])#定義位移矩陣，這里是沿x軸（沿水平方向订歪，向右移動100個像素位置）方向移動100個像素脖祈，沿y軸（沿豎直方向，向下移動200個像素位置）方向移動200個像素（通過將原圖與該矩陣進行四則運算實現(xiàn)圖像的位移）
dst=cv2.warpAffine(img,matShift,(height,width))#調用API刷晋，通過將原矩陣按照定義矩陣進行映射得到位移矩陣盖高。這里使用cv2.warpAffine(原圖矩陣,位移矩陣,(原圖高度,原圖寬度))福压，最終返回位移圖像矩陣
cv2.imshow('dst',dst)
cv2.waitKey(0)
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros(img.shape,np.uint8)#定義空白圖cv2像矩陣
for i in range(height):
for j in range(width-100):
dst[i,j+100]=img[i,j]
cv2.imshow('dst',dst)
cv2.waitKey(0)
**********圖片的鏡像**********
知識補充:
圖片的鏡像其實就是對圖像進行了翻轉（上下鏡像就是，每個像素點的x坐標不變或舞，y軸坐標上下對調）
y=2h-y-1
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬荆姆，高，通道數(shù)）
定義空白畫板的信息（就是定義空白圖像矩陣的信息映凳，寬胆筒，高，通道數(shù)）
創(chuàng)建一個高度為原圖片兩倍,寬度與原圖片相同的的畫板（就是空白矩陣）
在畫板上從上到小繪制原圖诈豌，然后再從下到上繪制原圖
在畫板中間繪制分割線
顯示鏡像圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
deep=imgInfo[2]
newImgInfo(height*2,width,deep)#定義空白畫板的信息（就是定義空白圖像矩陣的信息仆救，寬，高矫渔，通道數(shù)）
dst=np.zeros(newImgInfo,np.uint8)#創(chuàng)建一個高度為原圖片兩倍,寬度與原圖片相同的的畫板（就是空白矩陣）
for i in range(height):
for j in range(0,width):
dst[i,j]=img[i,j]#在畫板上從上到小繪制原圖
dst[height*2-i-1,j]=img[i,j]#從下到上繪制原圖
for i in range(0,width):
dst[height,i]=(0,0,255)#在畫板中間繪制分割線
cv2.imshow('dst',dst)
cv2.waitKey(0)
***********利用圖像位移來實現(xiàn)圖像的縮放*******************
知識補充：
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬彤蔽，高，通道數(shù)）
定義縮放矩陣
對圖像進行縮放
顯示縮放后的圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
matScale=np.float32([[0.5,0,0],[0,0.5,0]])
dst=cv2.warpAffine(img,matScale,(int(width/2),int(height/2)))
cv2.imshow('dst',dst)
cv2.waitKey(0)
************圖像的放射變換*************
知識補充：
圖像的放射變換庙洼，其實就是將圖像的像素點按照一定的規(guī)律映射到新的位置上
實際上也是求圖像中像素點的新的坐標的問題
放射變換并沒有確定的公式
一般是通過對圖像的三個點（左上角顿痪，左下角，右上角）的拉伸來實現(xiàn)放射變換
放射變換的實質就是將原圖像的三個點映射到目標圖像的三個新的位置上
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬油够，高蚁袭，通道數(shù)）
取原圖三個點
定義原圖上三個點在目標圖像上的新的坐標位置
調用API定義放射變換矩陣（通過原圖和放射變換矩陣進行四則運算最終得到放射后的目標圖像矩陣）
調用API進行放射變換得到目標圖像矩陣
顯示目標圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
matSrc=np.float32([[0,0],[0,height-1],[width-1,0]])#取原圖三個點
matDst=np.float32([[50,50],[300,height-200],[width-300,100]])#定義原圖上三個點在目標圖像上的新的坐標位置
matAffine=cv2.getAffineTransform(matSrc,matDst)#調用API定義放射變換矩陣。這里使用getAffineTransform(原圖三個點石咬，目標圖三點的新坐標）這個API揩悄，返回一個放射變換矩陣
dst=cv2.warpAffine(img,matAffine,(width,height))#調用API進行放射變換得到目標圖像矩陣
cv2.imshow('dst',dst)
cv2.waitKey(0)
*************圖片的旋轉**********
知識補充：
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬，高鬼悠，通道數(shù)）
調用API得到旋轉矩陣(通過將原圖與旋轉矩陣進行四則運算最終得到一個旋轉后的目標圖像)
調用API對得到目標圖像
顯示旋轉后的目標圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
matRotate=cv2.getRotationMatrix2D((height*0.5,width*0.5),45,0.5)#調用API得到旋轉矩陣,這里使用cv2.getRotationMatrix2D(旋轉的中心點坐標删性，旋轉的角度，縮放的系數(shù))這個API來獲得一個旋轉矩陣
dst=cv2.warpAffine(img,matRotate,(height,width))
cv2.imshow('dst',dst)
cv2.waitKey(0)
********圖像幾何變換小結*******
放射變換用在了圖像位移焕窝，旋轉蹬挺，縮放上
圖像幾何變幻的實質其實就是矩陣的運算（原圖與不同的系數(shù)矩陣進行四則運算就對原圖像完成了不同的幾何變換）
***********圖像的特效**********
知識補充：
灰度處理（普通灰度，底板效果）袜啃，馬賽克效果汗侵，毛玻璃效果，圖像融合群发，顏色變換晰韵，邊緣檢測，浮雕效果熟妓，油畫效果
這些都屬于圖像濾鏡的相關算法
使用opencv進行線段繪制雪猪、文字繪制（加字）、圖片繪制（加圖）等
直方圖的繪制（統(tǒng)計當前灰度等級出現(xiàn)的概率）
圖像檢測都是基于圖像的灰度特征（人臉檢測起愈、車牌檢測等等）
還是按照只恨，先API實現(xiàn)译仗，在根據(jù)算法原理編碼實現(xiàn)
灰度效果，其實就是完成彩色圖像灰度化的過程(是很多高級圖像處理的基礎官觅，是最重要的圖像效果算法纵菌，沒有之一，比如圖形的邊緣檢測休涤，人臉檢測等都是以灰度圖像為基礎咱圆。很多計算機視覺都要求實時處理，通過圖像的灰度化可以提高運算效果功氨，更好的實現(xiàn)實時圖像處理)
彩色圖像的三個顏色通道R序苏，G，B的值是互不相等的
灰度圖像的三個顏色通道R捷凄，G忱详，B等值是相等
如果要得到單通道的灰度圖像，那么他的通道值需要經過對彩色圖像的R,G,B值進行計算得到
兩種計算公式跺涤，一種是直接對R,G,B,取均值匈睁，另一種是根據(jù)心理學定義的按比例對R,G,B進行加權后相加的運算
opencv中用很多API都可以實現(xiàn)整個功能
比如imread(圖像名，0)钦铁，這里第二個參數(shù)設置為0软舌，就是將圖像按照灰度方式方式進行讀取
cvtColor,這個API也可以實現(xiàn)圖形的灰度化
也可以根據(jù)圖像灰度化的算法原理來編程實現(xiàn)圖像的灰度化
優(yōu)化灰度處理算法
定點元素速度比浮點運算快
+-操作比*/操作速度要快
>>才漆，<<操作比*/速度要快
基于以上三點可以實現(xiàn)圖像灰度算法的優(yōu)化
底板效果
彩色底板效果牛曹，其實就是對當前彩色圖像的R,G,B,值取反得到
灰度底板，是對灰度通道值取反得到
馬賽科效果
將要打馬賽克的區(qū)域劃分成一個個的小方框（方框的尺寸就是馬賽克的尺寸）
然后將方框中的所有像素點醇滥，全部用這個方框中的某一個像素點覆蓋黎比，使這個小方框中所有的像素值都是一樣的
馬賽克就是將方框中的所有像素點，用同一個像素點替代
毛玻璃效果
毛玻璃是將馬賽克的方框中的每個像素點鸳玩，從組成這個方框的所有像素點取一個來覆蓋（這樣方框中的每個點都是隨機的阅虫，都是不同的，而且都是屬于原來組成這個方框的像素點集）
融合效果
實現(xiàn)的是兩種圖片像素的融合
顏色映射
給定RGB顏色導向值不跟，然后圖像根據(jù)這個導向值修改RGB
邊緣檢測（也稱二值化）
保留的是整個圖像的細節(jié)信息（比較光滑平緩的地方就刪除掉了颓帝，只留下了輪廓和紋理）
浮雕效果：
在邊緣檢測的基礎上，再進行底板效果窝革，就形成了浮雕效果
思路：
引入opencv
調動API分別以灰度和彩色兩種形式讀取圖片
分別打印灰度圖像矩陣信息和彩色圖像矩陣信息
顯示灰度圖像
暫停
引入opencv
將圖像一彩色圖片形式讀取進來
調用API將彩色圖像轉換為灰度圖像
顯示灰度圖像
暫停
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬购城，高，通道數(shù)）
定義空白畫板
讀取原圖像素值并進行數(shù)據(jù)類型轉換（因為Uint8類型數(shù)在四則運算時有可能溢出虐译，所以要進行數(shù)據(jù)類型的轉換瘪板，轉換為int類型）瞻离，b對RGB取平均得到平均值并進行數(shù)據(jù)類型轉換（在再由int轉換為uint8）扬霜，使空白畫板相同坐標位置的像素點的RGB值都等于這個平均值（這就完成了圖像的灰度化）
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬本辐，高，通道數(shù)）
定義空白畫板
讀取原圖像素值并進行數(shù)據(jù)類型轉換（因為Uint8類型數(shù)在四則運算時有可能溢出跌造，所以要進行數(shù)據(jù)類型的轉換，轉換為int類型）展融，b對RGB運用心理學計算公式進行加權并求和蜗搔，然后進行數(shù)據(jù)類型轉換（在再由int轉換為uint8），使空白畫板相同坐標位置的像素點的RGB值都等于這個平均值（這就完成了圖像的灰度化）
優(yōu)化灰度算法
將小數(shù)放大為整數(shù)畦贸，運算結束后再進行縮小
進一步優(yōu)化將*1省略掉税朴，將*2用<<替換，將/4用>>替換
這樣提升了速度
代碼實現(xiàn)：
import cv2
img0=cv2.imread('1.jpg',0)
img1=cv2.imread('1.jpg',1)
print(img0.shape)#灰度圖像家制，顏色通道數(shù)為1（灰度圖像顏色是一維的正林，也就是單通道）
print(img1.shape)#彩色圖像，顏色通道數(shù)為3（彩色圖像顏色是三維的颤殴，也就是三通道）
cv2.imshow('src',img0)
cv2.waitKey(0)
import cv2
img0=cv2.imread('1.jpg',1)
dst=cv2.cvtColor(img,cv2.COLOR_BGRA2GRAY)#調用API將彩色圖像轉換為灰度圖像,這里使用cv2.cvtColor(原圖矩陣數(shù)據(jù)觅廓，顏色轉換的方式（就是定義轉換成那種）)這個API完成顏色空間的轉換（這里是由RGB顏色空間，轉換為灰度空間）
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]#讀取原圖像素值
gray=(int(b)+int(g)+int(r))/3#對原圖像素值并進行數(shù)據(jù)類型轉換（因為Uint8類型數(shù)在四則運算時有可能溢出涵但，所以要進行數(shù)據(jù)類型的轉換杈绸，轉換為int類型），b對RGB取平均得到平均值矮瘟。
dst[i,j]=np.uint8(gray)#進行數(shù)據(jù)類型轉換（在再由int轉換為uint8）瞳脓，使空白畫板相同坐標位置的像素點的RGB值都等于這個平均值（這就完成了圖像的灰度化）
dst
cv2.imshow('dst',dst)
cv2.waitKey(0)
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]#讀取原圖像素值
gray=int(b)*0.114+int(g)*0.587+int(r)*0.299#對原圖像素值并進行數(shù)據(jù)類型轉換（因為Uint8類型數(shù)在四則運算時有可能溢出，所以要進行數(shù)據(jù)類型的轉換澈侠，轉換為int類型）劫侧，對RGB運用心理學計算公式進行加權并求和
dst[i,j]=np.uint8(gray)#進行數(shù)據(jù)類型轉換（在再由int轉換為uint8），使空白畫板相同坐標位置的像素點的RGB值都等于這個平均值（這就完成了圖像的灰度化）
dst
cv2.imshow('dst',dst)
cv2.waitKey(0)
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]#讀取原圖像素值
gray=(int(b)*1+int(g)*2+int(r)*1)/4#對原圖像素值并進行數(shù)據(jù)類型轉換（因為Uint8類型數(shù)在四則運算時有可能溢出哨啃，所以要進行數(shù)據(jù)類型的轉換烧栋，轉換為int類型），對RGB運用心理學計算公式進行加權并求和拳球。這里進行了優(yōu)化审姓，先將浮點數(shù)左移兩位，運算結束后在右移兩位（提高了速度祝峻，但是增大了誤差）
dst[i,j]=np.uint8(gray)#進行數(shù)據(jù)類型轉換（在再由int轉換為uint8）魔吐，使空白畫板相同坐標位置的像素點的RGB值都等于這個平均值（這就完成了圖像的灰度化）
dst
cv2.imshow('dst',dst)
cv2.waitKey(0)
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]#讀取原圖像素值
gray=(int(b)+(int(g)<<1)+int(r))>>4#對原圖像素值并進行數(shù)據(jù)類型轉換（因為Uint8類型數(shù)在四則運算時有可能溢出，所以要進行數(shù)據(jù)類型的轉換莱找，轉換為int類型）酬姆，對RGB運用心理學計算公式進行加權并求和。這里進行了優(yōu)化宋距，先將浮點數(shù)左移兩位轴踱，運算結束后在右移兩位，并將*1省略掉谚赎，并用左移替換了*2淫僻，用右移替換/4（提高了速度诱篷，但是增大了誤差）
dst[i,j]=np.uint8(gray)#進行數(shù)據(jù)類型轉換（在再由int轉換為uint8），使空白畫板相同坐標位置的像素點的RGB值都等于這個平均值（這就完成了圖像的灰度化）
dst
cv2.imshow('dst',dst)
cv2.waitKey(0)
***************圖像顏色翻轉*********************
知識補充：
灰度圖像顏色翻轉：
對于灰度圖像雳灵，它的像素點的像素值（灰度值）取值范圍為0-255
對灰度圖像進行顏色翻轉棕所，其實就是對每一個像素，使他們的像素值=255-他們原來的像素值
彩色圖像顏色翻轉:
對于彩色圖像悯辙，它的像素點的像素值（灰度值）取值范圍也是0-255
對彩色圖像進行顏色翻轉琳省，其實就是對每一個像素點的RGB三個通道，使每個通道的像素值=255-他們原來的像素值
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬躲撰，高针贬，通道數(shù)）
對圖像進行灰度化
建立空白畫板
對灰度圖像進行顏色翻轉
顯示顏色翻轉后的目標圖像
暫停
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬，高拢蛋，通道數(shù)）
建立空白畫板
對灰度圖像進行顏色翻轉
顯示顏色翻轉后的目標圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
gray==cv2.cvtColor(img,cv2.COLOR_BGRA2GRAY)
dst=np.zeros((height,width,1),np.uint8)
for i in range(height):
for j in range(width):
grayPixel=gray[i,j]
dst[i,j]=255-grayPixel
cv2.imshow('dst',dst)
cv2.waitKey(0)
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,1),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
b=255-b
g=255-g
r=255-r
dst[i,j]=(b,g,r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
************圖片的馬賽克效果**********************
知識補充：
馬賽克效果的范圍（窗體范圍桦他，窗體形狀有矩形也有圓形）
思路：
引入 opencv
引入 numpy
讀取圖片
顯示圖片
獲取圖片信息（寬，高谆棱，通道數(shù)）
實現(xiàn)馬賽克效果
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
for m in range(100,300):
for n in range(100,200):
if m%10==0 and n%10==0:
for i in range(10):
for j in range(10):
(b,g,r)=img[m,n]
img[i+m,j+n]=(b,g,r)
cv2.imshow('dst',img)
cv2.waitKey(0)
*********圖片的毛玻璃效果***************
知識補充：
思路：
引入 opencv
引入 numpy
引入 random模塊
讀取圖片
顯示圖片
獲取圖片信息（寬快压，高，通道數(shù)）
定義空白畫板
實現(xiàn)毛玻璃效果
顯示毛玻璃效果
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
import random
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,3),np.uint8)
#mm=8
for m in range(height-8):
for n in range(width-8):
index=int(random.random()*8)
(b,g,r)=img[m+index,n+index]
dst[m,n]=(b,g,r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
*********************圖片的融合*********************
知識補充：
圖像融合時圖像大小必須保持一致
圖像融合實現(xiàn)公式
dst=src1*a+src2*(1-a)#目標圖像矩陣=原圖矩陣1*系數(shù)+原圖矩陣2*（1-系數(shù)）
思路：
引入 opencv
引入 numpy
讀取兩張圖片
獲取圖片信息（寬垃瞧，高蔫劣，通道數(shù)）
定義融合區(qū)域
定義空白畫板
調用API實現(xiàn)圖像的融合
顯示圖像融合效果
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img0=cv2.imread('11.jpg',1)
img1=cv2.imread('22.jpg',1)
imgInfo=img0.shape
height=imgInfo[0]
width=imgInfo[1]
roiH=int(height/2)
roiW=int(width/2)
img0ROI=img0[0:roiH,0:roiW]
img1ROI=img1[0:roiH,0:roiW]
dst=np.zeros((roiH,roiW,3),np.uint8)
dst=cv2.addWeighted(img0ROI,0.5,img1ROI,0.5,0)#調用API實現(xiàn)圖像的融合,此處調用addWeighted（圖src1，權重a个从，src2脉幢，權重(1-a)，0）,這個API 來實現(xiàn)兩個圖的加權和
cv2.imshow('dst',dst)
cv2.waitKey(0)
****************圖像的邊緣檢測******************
知識補充：
邊緣檢測的效果類似素描
用兩種算子分別實現(xiàn)邊緣檢測
邊緣檢測的實質就是對圖像進行卷積運算
邊緣檢測是基于灰度圖像的算法（所有的邊緣檢測算子都是基于灰度圖像來處理的）
sobel算子的算法原理
算子的模板信姓，有水平方向和豎直方向兩種
水平方向? ? ? ? ? ? ? ? ? ? ? ? 豎直方向
圖片卷積
卷積不同于矩陣四則運算
卷積是算子模板中每個元素與矩陣元素相乘再求和
卷積實例
閾值判決
經過卷積之后鸵隧，得到的結果，就是我們所說的梯度
梯度有水平方向和豎直方向兩種
f=sqrt(a*a+b*b)#a豎直方向上的算子與圖片卷積的結果數(shù)值（a其實就是豎直梯度）意推，b是水平方向上的算子與圖片卷積的結果（b其實就是水平梯度），sqrt是對括號內內容取平方根珊蟀。
將f與給定的門限值作比較菊值，若f大于門限值則認為該像素點為邊緣點
思路：
引入 opencv
引入 numpy
引入 random模塊
讀取圖片
顯示圖片
獲取圖片信息
對圖片進行灰度化
對圖片進行高斯濾波去燥
調用API實現(xiàn)邊緣檢測（這里氏使用opencv中的canny方法）
顯示邊緣檢測的圖像
暫停
引入 opencv
引入 numpy
引入 random模塊
讀取圖片
顯示圖片
獲取圖片信息
對圖片進行灰度化
創(chuàng)建空白畫板
計算豎直方向和水平反向上的梯度
計算整體梯度
根據(jù)sobel算子的算法原理實現(xiàn)圖像的邊緣檢測
顯示邊緣檢測的圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
import random
img=cv2.imread('1.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
imgG=cv2.GaussianBlur(gray,(3,3),0)#這里調用API對灰度圖像進行高斯濾波（參數(shù)1位灰度圖，參數(shù)2位模板大小育灸，參數(shù)3未知）
dst=cv2.Canny(imgG,50,50)#使用Canny(圖片腻窒，門限1，門限2）磅崭，如果圖像經過卷積之后儿子，圖像像素點的值若大于門限值，我們就認為這個點是邊緣點
cv2.imshow('dst',dst)
cv2.waitKey(0)
import cv2
import numpy as np
import random
import math
img=cv2.imread('a.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
dst=np.zeros((height,width,1),np.uint8)
for i in range(height-2):
? ? for j in range(width-2):
? ? ? ? gy=gray[i,j]*1+gray[i,j+1]*2+gray[i,j+2]*1-gray[i+2,j]*1-gray[i+2,j+1]*2-gray[i+2,j+2]*1#豎直方向上的梯度計算
? ? ? ? gx=gray[i,j]*1+gray[i+1,j]*2+gray[i+2,j]*1-gray[i,j+2]*1+gray[i+1,j+2]*2+gray[i+2,j+2]*1#水平方向上的梯度計算
? ? ? ? grad=math.sqrt(gx*gx+gy*gy)
? ? ? ? ?#print(grad)
? ? ? ? if grad>900:
? ? ? ? ? ? dst[i,j]=255?
? ? ? ? else:
? ? ? ? ? ? dst[i,j]=0
cv2.imshow('dst',dst)
cv2.waitKey(0)
****************圖像的浮雕效果************
知識補充：
浮雕效果與邊緣檢測原理相似砸喻，也是通過計算梯度來實現(xiàn)
浮雕效果的計算公式
newP=gray0-gray1+150#新的像素值=相鄰像素值之差+指定值
相鄰像素之差：為了突出邊緣特征
指定值：增強圖片灰度等級
思路：
引入 opencv
引入 numpy
引入 random模塊
讀取圖片
顯示圖片
獲取圖片信息
對圖片進行灰度化
定義空白畫板
根據(jù)浮雕效果算法原理實現(xiàn)浮雕效果
顯示浮雕效果圖片
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
import random
import math
img=cv2.imread('a.jpg',1)
cv2.imshow('src',img)
cv2.waitKey(0)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
dst=np.zeros((height,width,1),np.uint8)
for i in range(height):
for j in range(width-1):
grapyP0=int(gray[i,j])
grapyP1=int(gray[i,j+1])
newP=grapyP0-grapyP1+150
if newP>255:
newP=255
if newP<0:
newP=0
dst[i,j]=newP
cv2.imshow('dst',dst)
cv2.waitKey(0)
***********顏色風格變換**********
知識補充：
通過顏色映射來實現(xiàn)不同的顏色風格
最簡單的實現(xiàn)就是做一個RGB查找表柔逼，根據(jù)原始圖像RGB值在查找表上查找到一組新的RGB值蒋譬，然后用這個新的RGB值來代替原來的像素值（RGB值）
通過公式來進行顏色映射，但這只適用于簡單地顏色效果
因為顏色效果越復雜愉适，用公式進行擬合的難度會越大犯助，計算量甚至會超過制作一個查找表的工作量
藍色效果公式
b=b*1.5#把RGB中的藍色b乘以1.5進行增強
g=g*1.3#把RGB中的綠色g乘以1.3進行增強
思路：
引入 opencv
引入 numpy
讀取圖片
獲取圖片信息
建立空白畫板
根據(jù)藍色風格算法進行顏色映射
顯示藍色風格圖片
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('a.jpg',1)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
b*=1.5
g*=1.3
if b> 255:
b=255
? if g >255:
g=255
dst[i,j]=(b,g,r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
*************圖片的油畫效果***************************
知識補充：
將圖像灰度化
將灰度圖像分割為若干個小方框，統(tǒng)計每個小方框中每個像素點的灰度值
將0-255的灰度值劃分為n等級维咸，并將之前統(tǒng)計的灰度值按照這個等級進行劃分
找到每個方框中占比例最多的灰度等級的所有像素點剂买，并且對這些像素點的像素值求均值
用計算得到的平均值來代替原像素值
思路：
引入 opencv
引入 numpy
獲取圖片信息
對圖片進行灰度化
定義空白畫板
算法原理：
import cv2
import numpy as np
img=cv2.imread('a.jpg',1)
imgInfo=img.shape
height=imgInfo[0]
width=imgInfo[1]
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
dst=np.zeros((height,width,3),np.uint8)
for i in range(4，height-4):
for j in range(4癌蓖，width-4):
array1=np.zeros(8,np.uint8)
for m in range(-4,4):
for n in range(-4,4):
p1=int(gray[i+m,j+n]/32)
array1[p1]=array1[p1]+1
currentMax=array1[0]
l=0
for k in range(8):
if currentMax<array1[k]:
currentMax=array1[k]
l=k
for m in range(-4,4):
for n in range(-4,4):
if gray[i+m,j+n]>(l*32) and gray[i+m,j+n]<=(l+1)*32:
(b,g,r)=img[i+m,j+n]
dst[i,j]=(b,g,r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
********圖片上的線段繪制***********
知識補充:
思路：
引入opencv
引入numpy
自定義圖像的信息
創(chuàng)建自定義圖像
調用API繪制線段
繪制三角形
顯示繪制結果
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
newImageInfo=(500,500,3)
dst=np.zeros(newImageInfo,np.uint8)
cv2.line(dst,(100,100),(400,400),(0,0,255))#調用API繪制線段,line(原圖瞬哼，線段起點，線段終點租副，線段顏色)
cv2.line(dst,(100,200),(400,200),(0,255,255),20)#調用API繪制線段,line(原圖倒槐，線段起點，線段終點附井，線段顏色,線條寬度)
cv2.line(dst,(100,300),(400,300),(0,255,0),20,cv2.LINE_AA)#調用API繪制線段,line(原圖讨越，線段起點，線段終點永毅，線段顏色,線條寬度,線條類型)
cv2.line(dst,(200,150),(50,250),(25,100,255))
cv2.line(dst,(50,250),(400,380),(25,100,255))
cv2.line(dst,(400,380),(200,150),(25,100,255))
cv2.imshow('dst',dst)
cv2.waitKey(0)
********圖像的多邊形h繪制***********
知識補充：
思路：
引入opencv
引入numpy
自定義圖像的信息
創(chuàng)建自定義圖像
調用API繪制矩形
調用API繪制圓形
調用API繪制橢圓形
繪制任意多邊形
顯示繪制的圖形
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
newImageInfo=(500,500,3)
dst=np.zeros(newImageInfo,np.uint8)
cv2.rectangle(dst,(50,100),(200,300),(255,0,0),-1)#調用API繪制矩形把跨，rectangle（原圖矩陣，矩形左上角坐標沼死，矩形右下角坐標着逐，矩形顏色，是否填充）意蛀，最后一個參數(shù)若為-1表示填充矩陣耸别，若為>=0的數(shù)表示矩形線條的寬度
cv2.circle(dst,(250,250),(50),(0,255,0),2)#調用API繪制圓形,circle(原圖矩陣，圓心坐標县钥，半徑長度秀姐，圓形顏色，是否填充)若贮，最后一個參數(shù)若為-1表示填充矩陣省有，若為>=0的數(shù)表示圓形線條的寬度
cv2.ellipse(dst,(256,256),(150,100),0,0,180,(255,255,0),-1)#調用API繪制橢圓形,ellipse(原圖矩陣，橢圓圓心坐標谴麦，橢圓的長軸和短軸的長度蠢沿，偏轉角度，橢圓圓弧起始角度匾效，橢圓圓弧終止角度舷蟀，橢圓顏色，內容是否填充)
points=np.array([[150,50],[140,140],[200,170],[250,250],[150,50]],np.int32)#定義多變形的各個頂點坐標并且以數(shù)組形式保存
points=points.reshape((-1,1,2))#對數(shù)組進行維度轉換（這里是將二維數(shù)組（5,2）轉換成三維數(shù)組（5,1,2），這樣后續(xù)就可以根據(jù)這個三維數(shù)組繪制多邊形）
cv2.polylines(dst,[points],True,(0,255,255))#調用API繪制多邊形
cv2.imshow('dst',dst)
cv2.waitKey(0)
*********************在圖像上繪制圖片野宜、文字***************************
知識補充
思路：
引入opencv
引入numpy
讀入圖片
定義字體
調用API繪制矩形
調用API繪制文字
顯示繪制的文字
暫停
引入opencv
引入numpy
讀入圖片
縮放原圖產生新的圖片
將新圖片放在原圖上
顯示圖片繪制的效果
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('a.jpg',1)
font=cv2.FONT_HERSHEY_SIMPLEX
cv2.rectangle(img,(200,100),(500,400),(0,255,0),3)
cv2.putText(img,'this is flower',(100,300),font,1,(200,100,255),2,cv2.LINE_AA)#調用API繪制文字扫步，putText（原圖矩陣，文字內容速缨，文字的坐標锌妻，字體，字體的大小旬牲，文字顏色仿粹，字體的粗細，字體線條的類型）
cv2.imshow('img',img)
cv2.waitKey()
import cv2
img=cv2.imread('a.jpg',1)
height=int(img.shape[0]*0.2)
width=int(img.shape[1]*0.2)
imgResize=cv2.resize(img,(width,height))
for i in range(height):
for j in range(width):
img=[i+200,j+350]=imgResize[i,j]
cv2.imshow('src',img)
cv2.waitKey(0)
************圖片美化********
知識補充：
顏色等級的直方圖統(tǒng)計特征
RGB三種顏色的直方圖
橫坐標為顏色等級：0-255（8位的顏色深度原茅，2的8次方=256吭历，就是0-255）
縱坐標為每個顏色等級在整整圖片上出現(xiàn)的概率：0-1
直方圖均衡化
如果一付圖片上的直方圖沒有均勻分布，而是集中在某一處擂橘，
這時可以利用直方圖均衡化算法晌区，讓原本聚合在一起的直方圖盡可能的離散化
這個過程就被稱為直方圖的均衡化
直方圖的均衡化也分為對灰度圖像的均衡化和對彩色圖像的均衡化
經過直方圖均衡化后的圖像的亮度、清晰度等會視覺上感覺很漂亮
彩色圖像的直方圖均衡化
灰度圖像的直方圖均衡化
圖片美白
圖像的亮度增強
將當前的每個像素點的灰度值加上一個固定的值
或者將當前的每個像素點的灰度值乘以一個固定的放大系數(shù)（如1.1,1.2等）
這個算法是對整個圖像進行亮度增強
磨皮美白：
采用雙邊濾波器來實現(xiàn)
圖像濾波：
高斯濾波
使用API實現(xiàn)
中值濾波
根據(jù)算法原理通贞，編寫源碼
均值濾波
圖像的修復
如果圖像因為某些原因造成了污損朗若，可以采用圖像修復算法對圖像進行修復
****************圖像直方圖**********************
知識補充：
思路：
引入opencv
引入numpy
定義函數(shù)（用于直方圖的統(tǒng)計）
調用API完成直方圖的統(tǒng)計每種像素等級出現(xiàn)的次數(shù)h
調用API獲取直方圖中的最大值和最小值的坐標
創(chuàng)建空白畫布
畫布上繪制直方圖
h將歸一化數(shù)據(jù)在0-255之間
調用API繪制直方圖
顯示繪制好的直方圖
讀取圖片
調用API將圖像矩陣，分解為按照RGB三個通道分為三個矩陣
循環(huán)調用函數(shù)繪制直方圖
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
def ImageHist(image,type):
? ? color=(255,255,255)#定義顏色昌罩，此處為白色
? ? windowName='Gray'#定義窗體名稱
? ? if type==31:#表示藍色
? ? ? ? color=(255,0,0)
? ? ? ? windowName='B Hist'
? ? elif type==32:#表示綠色
? ? ? ? color=(0,255,0)
? ? ? ? windowName='G Hist'
? ? elif type==33:#表示紅色
? ? ? ? color=(0,0,255)
? ? ? ? windowName='R Hist'
? ? hist=cv2.calcHist([image],[0],None,[256],[0.0,255.0])#調用API完成直方圖的統(tǒng)計,calcHist([圖像矩陣],[直方圖的通道],mask蒙版,[直方圖橫坐標范圍],[直方圖中像素值范圍]])
? ? print(hist)
? ? minV,maxV,minL,maxL=cv2.minMaxLoc(hist)#調用API獲取直方圖中的最大值和最小值的坐標
? ? histImg=np.zeros([256,256,3],np.uint8)#創(chuàng)建空白畫布
? ? for h in range(256):
? ? ? ? intenNormal = int(hist[h]*256/maxV)
? ? ? ? cv2.line(histImg,(h,256),(h,256-intenNormal),color)
? ? cv2.imshow(windowName,histImg)
? ? return histImg
img=cv2.imread('a.jpg',1)
channels=cv2.split(img)#將RGB圖像分解為哭懈，R,G,B三個顏色通道
for i in range(3):
? ? print(channels[i])
? ? ImageHist(channels[i],31+i)
cv2.waitKey(0)
****************直方圖均衡化*******************
知識補充：
思路：
引入opencv
引入numpy
讀取圖片
實現(xiàn)圖像的灰度化
調用API完成灰度圖像的直方圖均衡化
顯示處理后的圖像
暫停
代碼實現(xiàn)：
import cv2
import numpy as np
img=cv2.imread('a.jpg',1)
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
cv2.imshow('img',gray)
dst=cv2.equalizeHist(gray)
******************補充*********************
監(jiān)督學習：有特征和標簽
分類問題：輸出是離散的數(shù)據(jù)
回歸問題：輸出是連續(xù)的數(shù)據(jù)
盡量把問題轉換為分類問題，這樣比較好處理
非監(jiān)督學習：沒有標簽
聚類：最常用K-means
密度估計：
入門sklearn(實現(xiàn)了很多機器學習的算法)
()
KNN茎用，用于minist
獲取原始圖像的時候遣总，每個環(huán)節(jié)都可能引入噪聲（比如放大圖像，圖像會模糊不清轨功，鋸齒狀旭斥，這就產生了噪聲）
引入噪聲的可能環(huán)節(jié)：傳感器質量差導致噪聲，光線差引入噪聲古涧，對圖像量化時引入噪聲
去除噪聲的操作叫圖像復原垂券，也叫圖像去噪，也叫圖像濾波（往往是我們拿到圖像之后的第一步操作）蒿褂。（圖像收到噪聲污染圆米，叫做圖像退化，去燥的過程就叫做復原）
常見的噪聲：加性噪聲（不論有誤信號啄栓，噪聲始終存在，噪聲與信號的關系是相加的關系也祠，一般把加性噪聲看成是系統(tǒng)的背景噪聲）昙楚，乘性噪聲（信號存在，則噪聲存在诈嘿，信號不存在堪旧，則噪聲不存在削葱，它與信號的關系是相乘的，把乘性噪聲看成是系統(tǒng)的變化噪聲）
常聽說的噪聲：白噪聲（功率譜在頻域內分布的噪聲）淳梦，高斯噪聲（高斯型的噪聲析砸，其實就是正態(tài)分布型噪聲）
濾波（也叫相關）算法：常說的圖像濾波是指空間濾波和頻率濾波
去燥：做平均（用滑動平均窗口，其實就是用卷積核來進行濾波爆袍，但計算方式與卷積不同）
高斯濾波：典型的高通濾波器首繁，完全把高頻阻斷，得到的圖像非常平滑（牢記高斯公式）
相關和卷積都是線性的運算（滿足線性運算的各中性質陨囊，比如交換律結合律等弦疮，在加速元算時很有用）
一種非線性濾波器：均值濾波器
邊緣檢測算法
全局特征
局部特征
SIFT
