欧美三区_成人在线免费观看视频_欧美极品少妇xxxxⅹ免费视频_a级毛片免费播放_鲁一鲁中文字幕久久_亚洲一级特黄

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡

系統(tǒng) 2271 0

該系列文章是講解Python OpenCV圖像處理知識,前期主要講解圖像入門、OpenCV基礎(chǔ)用法,中期講解圖像處理的各種算法,包括圖像銳化算子、圖像增強技術(shù)、圖像分割等,后期結(jié)合深度學(xué)習研究圖像識別、圖像分類應(yīng)用。希望文章對您有所幫助,如果有不足之處,還請海涵~

前文參考:
[Python圖像處理] 一.圖像處理基礎(chǔ)知識及OpenCV入門函數(shù)
[Python圖像處理] 二.OpenCV+Numpy庫讀取與修改像素
[Python圖像處理] 三.獲取圖像屬性、興趣ROI區(qū)域及通道處理
[Python圖像處理] 四.圖像平滑之均值濾波、方框濾波、高斯濾波及中值濾波
[Python圖像處理] 五.圖像融合、加法運算及圖像類型轉(zhuǎn)換
[Python圖像處理] 六.圖像縮放、圖像旋轉(zhuǎn)、圖像翻轉(zhuǎn)與圖像平移
[Python圖像處理] 七.圖像閾值化處理及算法對比
[Python圖像處理] 八.圖像腐蝕與圖像膨脹
[Python圖像處理] 九.形態(tài)學(xué)之圖像開運算、閉運算、梯度運算
[Python圖像處理] 十.形態(tài)學(xué)之圖像頂帽運算和黑帽運算
[Python圖像處理] 十一.灰度直方圖概念及OpenCV繪制直方圖
[Python圖像處理] 十二.圖像幾何變換之圖像仿射變換、圖像透視變換和圖像校正
[Python圖像處理] 十三.基于灰度三維圖的圖像頂帽運算和黑帽運算
[Python圖像處理] 十四.基于OpenCV和像素處理的圖像灰度化處理
[Python圖像處理] 十五.圖像的灰度線性變換
[Python圖像處理] 十六.圖像的灰度非線性變換之對數(shù)變換、伽馬變換
[Python圖像處理] 十七.圖像銳化與邊緣檢測之Roberts算子、Prewitt算子、Sobel算子和Laplacian算子
[Python圖像處理] 十八.圖像銳化與邊緣檢測之Scharr算子、Canny算子和LOG算子
[Python圖像處理] 十九.圖像分割之基于K-Means聚類的區(qū)域分割
[Python圖像處理] 二十.圖像量化處理和采樣處理及局部馬賽克特效
[Python圖像處理] 二十一.圖像金字塔之圖像向下取樣和向上取樣
[Python圖像處理] 二十二.Python圖像傅里葉變換原理及實現(xiàn)
[Python圖像處理] 二十三.傅里葉變換之高通濾波和低通濾波
[Python圖像處理] 二十四.圖像特效處理之毛玻璃、浮雕和油漆特效

前面一篇文章我講解了常見的圖像特效處理——毛玻璃、浮雕和油漆特效,本篇文章繼續(xù)分享素描特效、懷舊特效、光照特效、流年特效以及濾鏡特效。代碼通過Python和OpenCV實現(xiàn),基礎(chǔ)性文章,希望對你有所幫助。同時,該部分知識均為楊秀璋查閱資料撰寫,轉(zhuǎn)載請署名CSDN+楊秀璋及原地址出處,謝謝!!

1.圖像素描特效
2.圖像懷舊特效
3.圖像光照特效
4.圖像流年特效
5.圖像濾鏡特效
6.本文小結(jié)


PS:文章參考自己以前系列圖像處理文章及OpenCV庫函數(shù),同時參考如下文獻:
《數(shù)字圖像處理》(第3版),岡薩雷斯著,阮秋琦譯,電子工業(yè)出版社,2013年.
《數(shù)字圖像處理學(xué)》(第3版),阮秋琦,電子工業(yè)出版社,2008年,北京.
《OpenCV3編程入門》,毛星云,冷雪飛,電子工業(yè)出版社,2015,北京.
Eastmount - [Android] 通過Menu實現(xiàn)圖片懷舊、浮雕、模糊、光照和素描效果
使用python和opencv將圖片轉(zhuǎn)化為素描圖-python代碼解析
謝灰灰在找胡蘿蔔. IOS開發(fā)--使用lookup table為圖片添加濾鏡
百度百科. 濾鏡


一.圖像素描特效

圖像素描特效會將圖像的邊界都凸顯出來,通過邊緣檢測及閾值化處理能實現(xiàn)該功能。一幅圖像的內(nèi)部都具有相似性,而在圖像邊界處具有明顯的差異,邊緣檢測利用數(shù)學(xué)中的求導(dǎo)來擴大這種變化。但是求導(dǎo)過程中會增大圖像的噪聲,所以邊緣檢測之前引入了高斯濾波降噪處理。本文的圖像素描特效主要經(jīng)過以下幾個步驟:

  • 調(diào)用cv2.cvtColor()函數(shù)將彩色圖像灰度化處理;
  • 通過cv2.GaussianBlur()函數(shù)實現(xiàn)高斯濾波降噪;
  • 邊緣檢測采用Canny算子實現(xiàn);
  • 最后通過cv2.threshold()反二進制閾值化處理實現(xiàn)素描特效。

其運行代碼如下所示。

            
              
                #coding:utf-8
              
              
                import
              
               cv2

              
                import
              
               numpy 
              
                as
              
               np


              
                #讀取原始圖像
              
              
img 
              
                =
              
               cv2
              
                .
              
              imread
              
                (
              
              
                'scenery.png'
              
              
                )
              
              
                #圖像灰度處理
              
              
gray 
              
                =
              
               cv2
              
                .
              
              cvtColor
              
                (
              
              img
              
                ,
              
              cv2
              
                .
              
              COLOR_BGR2GRAY
              
                )
              
              
                #高斯濾波降噪
              
              
gaussian 
              
                =
              
               cv2
              
                .
              
              GaussianBlur
              
                (
              
              gray
              
                ,
              
              
                (
              
              
                5
              
              
                ,
              
              
                5
              
              
                )
              
              
                ,
              
              
                0
              
              
                )
              
              
                #Canny算子
              
              
canny 
              
                =
              
               cv2
              
                .
              
              Canny
              
                (
              
              gaussian
              
                ,
              
              
                50
              
              
                ,
              
              
                150
              
              
                )
              
              
                #閾值化處理
              
              
ret
              
                ,
              
               result 
              
                =
              
               cv2
              
                .
              
              threshold
              
                (
              
              canny
              
                ,
              
              
                100
              
              
                ,
              
              
                255
              
              
                ,
              
               cv2
              
                .
              
              THRESH_BINARY_INV
              
                )
              
              
                #顯示圖像
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'src'
              
              
                ,
              
               img
              
                )
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'result'
              
              
                ,
              
               result
              
                )
              
              
cv2
              
                .
              
              waitKey
              
                (
              
              
                )
              
              
cv2
              
                .
              
              destroyAllWindows
              
                (
              
              
                )
              
            
          

最終輸出結(jié)果如下圖所示,它將彩色圖像素描處理。原圖是作者去年九月份拍攝于喀納斯,真的很美~

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第1張圖片

圖像的素描特效有很多種方法,本文僅提供了一種方法,主要提取的是圖像的邊緣輪廓,還有很多更精細的素描特效方法,提取的輪廓更為清晰,如下圖所示。希望讀者能自行擴展相關(guān)算法知識,并實現(xiàn)對應(yīng)的效果。

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第2張圖片

二.圖像懷舊特效

圖像懷舊特效是指圖像經(jīng)歷歲月的昏暗效果,如圖所示,左邊“src”為原始圖像,右邊“dst”為懷舊特效圖像。

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第3張圖片

懷舊特效是將圖像的RGB三個分量分別按照一定比例進行處理的結(jié)果,其懷舊公式如下所示:

Python實現(xiàn)代碼主要通過雙層循環(huán)遍歷圖像的各像素點,再結(jié)合該公式計算各顏色通道的像素值,最終生成如圖所示的效果,其完整代碼如下。

            
              
                #coding:utf-8
              
              
                import
              
               cv2

              
                import
              
               numpy 
              
                as
              
               np


              
                #讀取原始圖像
              
              
img 
              
                =
              
               cv2
              
                .
              
              imread
              
                (
              
              
                'nana.png'
              
              
                )
              
              
                #獲取圖像行和列
              
              
rows
              
                ,
              
               cols 
              
                =
              
               img
              
                .
              
              shape
              
                [
              
              
                :
              
              
                2
              
              
                ]
              
              
                #新建目標圖像
              
              
dst 
              
                =
              
               np
              
                .
              
              zeros
              
                (
              
              
                (
              
              rows
              
                ,
              
               cols
              
                ,
              
              
                3
              
              
                )
              
              
                ,
              
               dtype
              
                =
              
              
                "uint8"
              
              
                )
              
              
                #圖像懷舊特效
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              rows
              
                )
              
              
                :
              
              
                for
              
               j 
              
                in
              
              
                range
              
              
                (
              
              cols
              
                )
              
              
                :
              
              
        B 
              
                =
              
              
                0.272
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                2
              
              
                ]
              
              
                +
              
              
                0.534
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                1
              
              
                ]
              
              
                +
              
              
                0.131
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                0
              
              
                ]
              
              
        G 
              
                =
              
              
                0.349
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                2
              
              
                ]
              
              
                +
              
              
                0.686
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                1
              
              
                ]
              
              
                +
              
              
                0.168
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                0
              
              
                ]
              
              
        R 
              
                =
              
              
                0.393
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                2
              
              
                ]
              
              
                +
              
              
                0.769
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                1
              
              
                ]
              
              
                +
              
              
                0.189
              
              
                *
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                0
              
              
                ]
              
              
                if
              
               B
              
                >
              
              
                255
              
              
                :
              
              
            B 
              
                =
              
              
                255
              
              
                if
              
               G
              
                >
              
              
                255
              
              
                :
              
              
            G 
              
                =
              
              
                255
              
              
                if
              
               R
              
                >
              
              
                255
              
              
                :
              
              
            R 
              
                =
              
              
                255
              
              
        dst
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                =
              
               np
              
                .
              
              uint8
              
                (
              
              
                (
              
              B
              
                ,
              
               G
              
                ,
              
               R
              
                )
              
              
                )
              
              
                #顯示圖像
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'src'
              
              
                ,
              
               img
              
                )
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'dst'
              
              
                ,
              
               dst
              
                )
              
              
cv2
              
                .
              
              waitKey
              
                (
              
              
                )
              
              
cv2
              
                .
              
              destroyAllWindows
              
                (
              
              
                )
              
            
          

三.圖像光照特效

圖像光照特效是指圖像存在一個類似于燈光的光暈特效,圖像像素值圍繞光照中心點呈圓形范圍內(nèi)的增強。如下圖所示,該圖像的中心點為(192,192),光照特效之后中心圓范圍內(nèi)的像素增強了200。

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第4張圖片

Python實現(xiàn)代碼主要是通過雙層循環(huán)遍歷圖像的各像素點,尋找圖像的中心點,再通過計算當前點到光照中心的距離(平面坐標系中兩點之間的距離),判斷該距離與圖像中心圓半徑的大小關(guān)系,中心圓范圍內(nèi)的圖像灰度值增強,范圍外的圖像灰度值保留,并結(jié)合邊界范圍判斷生成最終的光照效果。

            
              
                #coding:utf-8
              
              
                import
              
               cv2

              
                import
              
               math

              
                import
              
               numpy 
              
                as
              
               np


              
                #讀取原始圖像
              
              
img 
              
                =
              
               cv2
              
                .
              
              imread
              
                (
              
              
                'scenery.png'
              
              
                )
              
              
                #獲取圖像行和列
              
              
rows
              
                ,
              
               cols 
              
                =
              
               img
              
                .
              
              shape
              
                [
              
              
                :
              
              
                2
              
              
                ]
              
              
                #設(shè)置中心點
              
              
centerX 
              
                =
              
               rows 
              
                /
              
              
                2
              
              
centerY 
              
                =
              
               cols 
              
                /
              
              
                2
              
              
                print
              
               centerX
              
                ,
              
               centerY
radius 
              
                =
              
              
                min
              
              
                (
              
              centerX
              
                ,
              
               centerY
              
                )
              
              
                print
              
               radius


              
                #設(shè)置光照強度
              
              
strength 
              
                =
              
              
                200
              
              
                #新建目標圖像
              
              
dst 
              
                =
              
               np
              
                .
              
              zeros
              
                (
              
              
                (
              
              rows
              
                ,
              
               cols
              
                ,
              
              
                3
              
              
                )
              
              
                ,
              
               dtype
              
                =
              
              
                "uint8"
              
              
                )
              
              
                #圖像光照特效
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              rows
              
                )
              
              
                :
              
              
                for
              
               j 
              
                in
              
              
                range
              
              
                (
              
              cols
              
                )
              
              
                :
              
              
                #計算當前點到光照中心距離(平面坐標系中兩點之間的距離)
              
              
        distance 
              
                =
              
               math
              
                .
              
              
                pow
              
              
                (
              
              
                (
              
              centerY
              
                -
              
              j
              
                )
              
              
                ,
              
              
                2
              
              
                )
              
              
                +
              
               math
              
                .
              
              
                pow
              
              
                (
              
              
                (
              
              centerX
              
                -
              
              i
              
                )
              
              
                ,
              
              
                2
              
              
                )
              
              
                #獲取原始圖像
              
              
        B 
              
                =
              
                img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                0
              
              
                ]
              
              
        G 
              
                =
              
                img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                1
              
              
                ]
              
              
        R 
              
                =
              
               img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                2
              
              
                ]
              
              
                if
              
              
                (
              
              distance 
              
                <
              
               radius 
              
                *
              
               radius
              
                )
              
              
                :
              
              
                #按照距離大小計算增強的光照值
              
              
            result 
              
                =
              
              
                (
              
              
                int
              
              
                )
              
              
                (
              
              strength
              
                *
              
              
                (
              
              
                1.0
              
              
                -
              
               math
              
                .
              
              sqrt
              
                (
              
              distance
              
                )
              
              
                /
              
               radius 
              
                )
              
              
                )
              
              
            B 
              
                =
              
               img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                0
              
              
                ]
              
              
                +
              
               result
            G 
              
                =
              
               img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                1
              
              
                ]
              
              
                +
              
               result
            R 
              
                =
              
               img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                2
              
              
                ]
              
              
                +
              
               result
            
              
                #判斷邊界 防止越界
              
              
            B 
              
                =
              
              
                min
              
              
                (
              
              
                255
              
              
                ,
              
              
                max
              
              
                (
              
              
                0
              
              
                ,
              
               B
              
                )
              
              
                )
              
              
            G 
              
                =
              
              
                min
              
              
                (
              
              
                255
              
              
                ,
              
              
                max
              
              
                (
              
              
                0
              
              
                ,
              
               G
              
                )
              
              
                )
              
              
            R 
              
                =
              
              
                min
              
              
                (
              
              
                255
              
              
                ,
              
              
                max
              
              
                (
              
              
                0
              
              
                ,
              
               R
              
                )
              
              
                )
              
              
            dst
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                =
              
               np
              
                .
              
              uint8
              
                (
              
              
                (
              
              B
              
                ,
              
               G
              
                ,
              
               R
              
                )
              
              
                )
              
              
                else
              
              
                :
              
              
            dst
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                =
              
               np
              
                .
              
              uint8
              
                (
              
              
                (
              
              B
              
                ,
              
               G
              
                ,
              
               R
              
                )
              
              
                )
              
              
                #顯示圖像
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'src'
              
              
                ,
              
               img
              
                )
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'dst'
              
              
                ,
              
               dst
              
                )
              
              
cv2
              
                .
              
              waitKey
              
                (
              
              
                )
              
              
cv2
              
                .
              
              destroyAllWindows
              
                (
              
              
                )
              
            
          

四.圖像流年特效

流年是用來形容如水般流逝的光陰或年華,圖像處理中特指將原圖像轉(zhuǎn)換為具有時代感或歲月沉淀的特效,其效果如圖所示。

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第5張圖片

Python實現(xiàn)代碼如下,它將原始圖像的藍色(B)通道的像素值開根號,再乘以一個權(quán)重參數(shù),產(chǎn)生最終的流年效果。

            
              
                #coding:utf-8
              
              
                import
              
               cv2

              
                import
              
               math

              
                import
              
               numpy 
              
                as
              
               np


              
                #讀取原始圖像
              
              
img 
              
                =
              
               cv2
              
                .
              
              imread
              
                (
              
              
                'scenery.png'
              
              
                )
              
              
                #獲取圖像行和列
              
              
rows
              
                ,
              
               cols 
              
                =
              
               img
              
                .
              
              shape
              
                [
              
              
                :
              
              
                2
              
              
                ]
              
              
                #新建目標圖像
              
              
dst 
              
                =
              
               np
              
                .
              
              zeros
              
                (
              
              
                (
              
              rows
              
                ,
              
               cols
              
                ,
              
              
                3
              
              
                )
              
              
                ,
              
               dtype
              
                =
              
              
                "uint8"
              
              
                )
              
              
                #圖像流年特效
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              rows
              
                )
              
              
                :
              
              
                for
              
               j 
              
                in
              
              
                range
              
              
                (
              
              cols
              
                )
              
              
                :
              
              
                #B通道的數(shù)值開平方乘以參數(shù)12
              
              
        B 
              
                =
              
               math
              
                .
              
              sqrt
              
                (
              
              img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                0
              
              
                ]
              
              
                )
              
              
                *
              
              
                12
              
              
        G 
              
                =
              
                img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                1
              
              
                ]
              
              
        R 
              
                =
              
                img
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                [
              
              
                2
              
              
                ]
              
              
                if
              
               B
              
                >
              
              
                255
              
              
                :
              
              
            B 
              
                =
              
              
                255
              
              
        dst
              
                [
              
              i
              
                ,
              
              j
              
                ]
              
              
                =
              
               np
              
                .
              
              uint8
              
                (
              
              
                (
              
              B
              
                ,
              
               G
              
                ,
              
               R
              
                )
              
              
                )
              
              
                #顯示圖像
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'src'
              
              
                ,
              
               img
              
                )
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'dst'
              
              
                ,
              
               dst
              
                )
              
              
cv2
              
                .
              
              waitKey
              
                (
              
              
                )
              
              
cv2
              
                .
              
              destroyAllWindows
              
                (
              
              
                )
              
            
          

五.圖像濾鏡特效

濾鏡主要是用來實現(xiàn)圖像的各種特殊效果,它在Photoshop中具有非常神奇的作用。濾鏡通常需要同通道、圖層等聯(lián)合使用,才能取得最佳藝術(shù)效果。本小節(jié)將講述一種基于顏色查找表(Look up Table)的濾鏡處理方法,它通過將每一個原始顏色進行轉(zhuǎn)換之后得到新的顏色。比如,原始圖像的某像素點為紅色(R-255, G-0, B-0),進行轉(zhuǎn)換之后變?yōu)榫G色(R-0, G-255, B-0),之后所有是紅色的地方都會被自動轉(zhuǎn)換為綠色,而顏色查找表就是將所有的顏色進行一次(矩陣)轉(zhuǎn)換,很多的濾鏡功能就是提供了這么一個轉(zhuǎn)換的矩陣,在原始色彩的基礎(chǔ)上進行顏色的轉(zhuǎn)換。

假設(shè)現(xiàn)在存在一張新的濾鏡顏色查找表,如圖所示,它是一張512×512大小,包含各像素顏色分布的圖像。下面這張圖片另存為本地,即可直接用于圖像濾鏡處理。

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第6張圖片

濾鏡特效實現(xiàn)的Python代碼如下所示,它通過自定義getBRG()函數(shù)獲取顏色查找表中映射的濾鏡顏色,再依次循環(huán)替換各顏色。

            
              
                #coding:utf-8
              
              
                import
              
               cv2

              
                import
              
               numpy 
              
                as
              
               np


              
                #獲取濾鏡顏色
              
              
                def
              
              
                getBGR
              
              
                (
              
              img
              
                ,
              
               table
              
                ,
              
               i
              
                ,
              
               j
              
                )
              
              
                :
              
              
                #獲取圖像顏色
              
              
    b
              
                ,
              
               g
              
                ,
              
               r 
              
                =
              
               img
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                #計算標準顏色表中顏色的位置坐標
              
              
    x 
              
                =
              
              
                int
              
              
                (
              
              g
              
                /
              
              
                4
              
              
                +
              
              
                int
              
              
                (
              
              b
              
                /
              
              
                32
              
              
                )
              
              
                *
              
              
                64
              
              
                )
              
              
    y 
              
                =
              
              
                int
              
              
                (
              
              r
              
                /
              
              
                4
              
              
                +
              
              
                int
              
              
                (
              
              
                (
              
              b
              
                %
              
              
                32
              
              
                )
              
              
                /
              
              
                4
              
              
                )
              
              
                *
              
              
                64
              
              
                )
              
              
                #返回濾鏡顏色表中對應(yīng)的顏色
              
              
                return
              
               lj_map
              
                [
              
              x
              
                ]
              
              
                [
              
              y
              
                ]
              
              
                #讀取原始圖像
              
              
img 
              
                =
              
               cv2
              
                .
              
              imread
              
                (
              
              
                'scenery.png'
              
              
                )
              
              
lj_map 
              
                =
              
               cv2
              
                .
              
              imread
              
                (
              
              
                'table.png'
              
              
                )
              
              
                #獲取圖像行和列
              
              
rows
              
                ,
              
               cols 
              
                =
              
               img
              
                .
              
              shape
              
                [
              
              
                :
              
              
                2
              
              
                ]
              
              
                #新建目標圖像
              
              
dst 
              
                =
              
               np
              
                .
              
              zeros
              
                (
              
              
                (
              
              rows
              
                ,
              
               cols
              
                ,
              
              
                3
              
              
                )
              
              
                ,
              
               dtype
              
                =
              
              
                "uint8"
              
              
                )
              
              
                #循環(huán)設(shè)置濾鏡顏色
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              rows
              
                )
              
              
                :
              
              
                for
              
               j 
              
                in
              
              
                range
              
              
                (
              
              cols
              
                )
              
              
                :
              
              
        dst
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                =
              
               getBGR
              
                (
              
              img
              
                ,
              
               lj_map
              
                ,
              
               i
              
                ,
              
               j
              
                )
              
              
                #顯示圖像
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'src'
              
              
                ,
              
               img
              
                )
              
              
cv2
              
                .
              
              imshow
              
                (
              
              
                'dst'
              
              
                ,
              
               dst
              
                )
              
              

cv2
              
                .
              
              waitKey
              
                (
              
              
                )
              
              
cv2
              
                .
              
              destroyAllWindows
              
                (
              
              
                )
              
            
          

濾鏡特效的運行結(jié)果如圖所示,其中左邊“src”為原始風景圖像,右邊“dst”為濾鏡處理后的圖像,其顏色變得更為鮮艷,對比度更強。

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第7張圖片

六.本文小結(jié)

本篇文章主要講解了圖像常見的特效處理,從處理效果圖、算法原理、代碼實現(xiàn)三個步驟進行詳細講解,涉及圖像素描特效、懷舊特效、光照特效、流年特效、圖像濾鏡等,這些知識點將為讀者從事Python圖像處理相關(guān)項目實踐或科學(xué)研究提供一定基礎(chǔ)。

八年,從100萬名擠進2萬名,再到如今的top300,挺開心的。喜歡的不是那個數(shù)字,而是數(shù)字背后近三千天得奮斗史,以及分享知識和幫人解惑所帶來的快樂,最近總結(jié)了安全系列,且看且珍惜,繼續(xù)敲代碼嘍~

[Python圖像處理] 二十五.圖像特效處理之素描、懷舊、光照、流年以及濾鏡特效_第8張圖片

(By:Eastmount 2019-08-14 下午3點寫于鐘書閣 https://blog.csdn.net/Eastmount )


更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯(lián)系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發(fā)表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 免费一级在线 | 亚洲欧美不卡 | 色噜噜狠狠色综合久 | 国产精品综合色区小说 | 久久国产精品久久 | 天天久久狠狠色综合 | 欧美三级 在线播放 | 日本高清免费zzzzzzzz | 亚洲欧美另类综合 | 亚洲午夜久久久精品影院 | 一级成人毛片免费观看欧美 | 欧美性bbbbbxxxxxddd| 亚洲欧美18v中文字幕高清 | 国产在视频一区二区三区吞精 | 精品国产一区探花在线观看 | 久久中文字幕在线 | 98色花堂国产第一页 | 国产一区久久精品 | 国产成人无码网站m3u8 | 男女真实有遮挡xx00动态图 | 免费激情视频在线观看 | 天天躁日日躁狠狠躁中文字幕 | 边摸边吃奶边做激情叫床 | 免费黄色日韩电影 | 99精彩视频 | 国产福利视频一区 | aaaaaaa片毛片免费观看 | 欧美成a高清在线观看www | 免费高清精品国偷自产在线 | 欧美一级久久久久久久大片 | 国产在线网站 | 日韩在线免费视频 | 亚洲欧美综合乱码精品成人网 | 日韩在线视频精品 | 欧美日韩亚洲在线 | 国产真实精品久久二三区 | 日韩中文视频 | 一区二区三区四区国产精品视频 | 国产一区二区精品在线观看 | 新白娘子传奇50集免费赵雅芝版 | 性夜影院爽黄a爽在线看香蕉 |