图像处理骚操作

骑猪看日落 2023-06-25 06:28 3阅读 0赞

（一）
    #1文件的读取 2封装格式解析 3数据解码 4数据加载
    import cv2
    img=cv2.imread('D://img//0.jpg')
    cv2.imshow("heheda",img)
    #jpg png 1文件头  2文件数据
    cv2.waitKey(0)
    （二）
    import cv2
    cv2.imread("D://img//0.jpg",1)
    cv2.imwrite("D://img//4.jpg",img)#1 name 2 data
    （三）
    #jpg是有损压缩
    import cv2
    img=cv2.imread("D://img//0.jpg",1)
    cv2.imwrite('D://img//5.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,50])
    #1MN 100k 10k 0-100有损压缩 以牺牲图片质量的压缩
    （四）
    #1无损2透明度属性
    import cv2
    img=cv2.imread("D://img//0.jpg",1)
    cv2.imwrite("D://img//0.png",img,[cv2.IMWRITE_JPEG_QUALITY,0])
    #jpg 0 压缩比率高 0-100 0 压缩比率是0-9
    （五）
    import cv2
    img=cv2.imread("D://img//0.jpg",1)
    (b,g,r)=img[100,100]
    print(b,g,r)
    for i in range(0,100):
        img[10+i,100]=(255,0,0)  
    cv2.imshow('D://img//4.jpg',img)
    cv2.waitKey(0)
    （六）
    #opencv tensorflow
    #类比 基础语法 api调用 原理 
    #基础数据类型 运算符 流程 字典 数组
    #常量和变量的使用
    import tensorflow as tf
    data1=tf.constant(2,dtype=tf.int32)
    data2=tf.Variable(10,name='var')
    print(data1)
    print(data2)
    '''sess=tf.Session()
    print(sess.run(data1))
    init=tf.global_variables_initializer()
    sess.run(init)
    print(sess.run(data2))
    sess.close()
    '''
    init=tf.global_variables_initializer()
    sess=tf.Session()
    with sess:
        sess.run(init)
        print(sess.run(data2))
    （七）
    #tensorflow 运算实质
    #tensorflow的实质：张量tensor+计算图grahps
    #本质 tf=tensor+计算图
    #tensor数据
    #op operation（赋值操作，四则运算）
    #graphs数据操作
    #session运算的交互环境
    （八）
    #常量与变量的四则运算
    import tensorflow as tf
    data1=tf.constant(6)
    data2=tf.constant(2)
    dataAdd=tf.add(data1,data2)
    dataMul=tf.multiply(data1,data2)
    dataSub=tf.subtract(data1,data2)
    dataDiv=tf.divide(data1,data2)
    with tf.Session() as sess:
        print(sess.run(dataAdd))
        print(sess.run(dataMul))
        print(sess.run(dataSub))
        print(sess.run(dataDiv))
    print('end')
    （九）
    #常量与变量的四则运算
    import tensorflow as tf
    data1=tf.constant(6)
    data2=tf.Variable(2)
    dataAdd=tf.add(data1,data2)
    dataCopy=tf.assign(data2,dataAdd)#dataAdd->data2
    dataMul=tf.multiply(data1,data2)
    dataSub=tf.subtract(data1,data2)
    dataDiv=tf.divide(data1,data2)
    init=tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)#所有变量必须进行初始化
        print(sess.run(dataAdd))
        print(sess.run(dataMul))
        print(sess.run(dataSub))
        print(sess.run(dataDiv))
    #     print('sess.run(dataCopy)',sess.run(dataCopy))#8->data2
    #     print('dataCopy.eval()',dataCopy.eval())#8+6->data=14
        print('tf.get_default_session()',tf.get_default_session().run(dataCopy))
    print('end')
    （十）
    #placeholder
    import tensorflow as tf
    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={1:6,2:2}}
    print("end!")
    （十一）
    #类比 数组 M行N列 [] 内部[] [里面 列数据] [] 中括号整体行数
    #[[6,6]] [[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)#维度
    with tf.Session() as sess:
        print(sess.run(data4))
        print(sess.run(data4[0]))#打印某一行
        print(sess.run(data4[:,0]))#打印某一列
    print(sess.run(data4[0,1]))#1 1
    （十二）
    #矩阵运算
    #矩阵大下：M*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)
    matMul2=tf.multiply(data1,data2)
    matAdd=tf.add(data1,data3)
    with tf.Session() as sess:
        print(sess.run(matMul))#1维 M=1 N=2 1*2（MK） 2*1（KN）=1
        print(sess.run(matAdd))#1行2列
        print(sess.run(matMul2))#对应的元素相乘 1*2 2*1 =2*2
        print(sess.run([matMul,matAdd]))#中括号方式一次打印
    #对应的元素相乘
    （十三）
    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.Session() as sess:
    #     print(sess.run(mat0))
    #     print(sess.run(mat1))
    #     print(sess.run(mat2))
    print(sess.run(mat3))
    （十四）
    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.random_uniform([2,3],-1,2)
    with tf.Session() as sess:
        print(sess.run(mat2))
        print(sess.run(mat3))
    print(sess.run(mat4))
    （十五）
    #CURD
    import numpy as np
    data1=np.array([1,2,3,4,5])
    print(data1)
    data2=np.array([[1,2],[3,4]])
    print(data2)
    #维度
    print(data1.shape,data2.shape)
    #空矩阵
    print(np.zeros([2,3]),np.ones([2,2]))
    #改查
    data2[1,0]=5
    print(data2)
    print(data2[1,1])
    #基本运算
    data3=np.ones([2,3])
    print(data3*2)#对应相乘
    print(data3/3)#对应的元素相除
    print(data3+2)
    #矩阵的加法和乘法
    data4=np.array([[1,2,3],[4,5,6]])
    print(data3+data4)
    print(data3*data4)
    （十六）
    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 t 3 color
    plt.plot(x,y,'g',lw=10)#4 line w
    
    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')#5 color  4透明度 3 0.9占填充比例
    plt.show()
    （十七）
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    date=np.linspace(1,15,15)
    endPrice=np.array([1111,2222,3333,4444,5555,6666,])
    beginPrice=np.array([2222,3333,4444,5555,6666,1000])
    print(date)
    plt.figure()
    for i in range(0,6):
        #1 柱状图
        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()
    （十八）
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    date=np.linspace(1,15,15)
    endPrice=np.array([1111,2222,3333,4444,5555,6666,])
    beginPrice=np.array([2222,3333,4444,5555,6666,1000])
    print(date)
    plt.figure()
    for i in range(0,6):
        #1 柱状图
        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()
    （十九）
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    date=np.linspace(1,6,6)
    endPrice=np.array([2511.90,2538.26,2510.68,2591.66,2732.98,2701.69])
    beginPrice=np.array([2701.69,2511.90,2538.26,2510.68,2591.66,2732.98])
    print(date)
    plt.figure()
    for i in range(0,6):
        #1 柱状图
        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()
    （二十）
    #图片缩放
    #1 load 2 info 3 resize 4 check
    import cv2
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    print(imgInfo)
    height=imgInfo[0]
    width=imgInfo[1]
    mode=imgInfo[2]
    #1 放大 缩小 2等比例 非2:3
    dstHeight=int(height*0.5)
    dstWidth=int(width*0.5)
    #最近邻域插值 双线性插值 像素关系重采样 立方插值
    dst=cv2.resize(img,(dstWidth,dstHeight))
    cv2.imshow('image',dst)
    cv2.waitKey(0)
    （二十一）
    #最近邻域插值 双线性插值 原理
    #src 10*20 dst 5*10
    #dst<-src
    #(1,2)<-(2,4)
    #dst x 1->src x 2 newx
    #newx=x*(src行/目标 行)newx=1*(10/5)=2
    （二十二）
    import cv2
    import numpy as np
    img=cv2.imread('D://img/0.jpg')
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    dstHeight=int(height/2)
    dstWidth=int(width/2)
    dstImage=np.zeros((dstHeight,dstWidth,3),np.uint8)
    for i in range(0,dstHeight):
        for j in range(0,dstWidth):
            iNew=int(i*(height*1.0/dstHeight))
            jNew=int(j*(width*1.0/dstWidth))
            dstImage[i,j]=img[iNew,jNew]
    cv2.imshow('dst',dstImage)
    cv2.waitKey(0)
    （二十三）
    import cv2
    img=cv2.imread("d://img/0.jpg",1)
    imgInfo=img.shape
    dst=img[100:200,100:300]
    cv2.imshow("image",dst)
    cv2.waitKey(0)
    （二十四）
    import cv2
    import numpy as np
    img=cv2.imread('d://img//0.jpg',1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    dstHeight=int(height/2)
    dstWidth=int(width/2)
    print(dstHeight)
    print(dstWidth)
    dstImage=np.zeros((dstHeight,dstWidth,3),np.uint8)#0-255
    #将原图片的坐标的像素值赋值给缩放后图片的坐标的空像素值 遍历图片的所有像素值的坐标 将其坐标与其缩放后的图片的坐标进行对应
    #原图片的单位坐标进行缩放，进而可以得到整张图片的缩放
    for i in range(0,dstHeight):
        for j in range(0,dstWidth):
            iNew=int(i*(height*1.0/dstHeight))
            jNew=int(j*(width*1.0/dstWidth))
            dstImage[i,j]=img[iNew,jNew]
    print(dstImage[0])
    cv2.imshow('dst',dstImage)
    cv2.waitKey(0)
    #1 opencv API resize 2 算法原理 3 源码
    （二十五）
    #图片剪切
    #100->>200 x
    #100->>300 y
    import cv2
    cv2.imread('d://img//0.jpg',1)
    imgInfo=img.reshape
    dst=img[100:200,100:300]
    cv2.imshow('image',dst)
    cv2.waitKey(0)
    （二十六）
    #1 API 2 算法原理 3 源代码 
    #通过opencv的API
    import cv2
    import numpy as np
    img=cv2.imread('d://img//0.jpg',1)
    cv2.imshow('src',img)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    ####
    matShift=np.float32([[1,0,100],[0,1,200]])#两行三列
    dst=cv2.warpAffine(img,matShift,(height,width))#1 data 2 mat 3 info
    #移位 矩阵
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （二十七）
    #API 级别的像素级别的应用
    #[1,0,100],[0,1,200] 2*2 2*1
    #[[1,0],[0,1]] 2*2 A
    #[[100],[100]] 2*1 B
    #xy C
    #用到了y=ax+b线性方程思想
    #A*C+B=[[1*x+0*y],[0*x+1*y]]+[[100],[100]]
    #=[[x+100],[y+100]]
    #像素级别实现移动
    #(10,20)->(110,220)
    （二十八）
    import cv2
    import numpy as np
    img=cv2.imread('d://img/0.jpg',1)
    cv2.imshow('src',img)
    imgInfo=img.shape
    dst=np.zeros(img.shape,np.uint8)
    height=imgInfo[0]
    width=imgInfo[1]
    #实现原理很简单 ： 其实就是先规定出裁剪之后的图片的大小，然后这张图片的起始原点位置所位于的坐标位置
    #然后将其原图片对应的像素值对应到裁剪之后的图片的坐标位置
    for i in range(0,height):
        for j in range(0,width-100):
            dst[i,j+100]=img[i,j]
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （二十九）
    #图片镜像
    #实现步骤
    #创建一个足够大的"画板"
    #将一副图像分别从前向后，从后向前绘制
    #绘制中心分割线
    （三十）
    import cv2 
    import numpy as np 
    img=cv2.imread('d://img//0.jpg',1) 
    cv2.imshow('src',img)
    imgInfo=img.shape 
    height=imgInfo[0] 
    width=imgInfo[1] 
    deep=imgInfo[2] 
    newImgInfo=(height*2,width,deep) 
    dst=np.zeros(newImgInfo,np.uint8)#uint8 
    #利用像素点的镜相对应坐标实现，镜像图片
    for i in range(0,height):
        for j in range(0,width): 
            dst[i,j]=img[i,j]
            #x y=2*h-y-1
            dst[height*2-i-1,j]=img[i,j]
    for i in range(0,width): 
        dst[height,i]=(0,0,255)#BGR 
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （三十一）
    #[[A1 A2 B1],[A3 A4 B2]]
    #[[A1 A2],[A3 A4]] [[B1],[B2]]
    #newX=A1*x+A2*y+B1
    #newY=A3*x+A4*y+B2
    #x->x*0.5y->y*05
    #newX=0.5*x
    import cv2
    import numpy as np
    img=cv2.imread('d://img//0.jpg',1)
    cv2.imshow('src',img)
    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)
    （三十二）
    #仿射变换：位移 旋转 缩放
    import cv2
    import numpy as np
    img=cv2.imread('d://img/0.jpg',1)
    cv2.imshow('src',img)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #src 3->dst 3 (左上角 左下角 右上角)
    matSrc = np.float32([[0,0],[0,height-1],[width-1,0]])
    matDst = np.float32([[50,50],[300,height-100],[width-200,100]])
    #组合
    matAffine=cv2.getAffineTransform(matSrc,matDst)
    dst=cv2.warpAffine(img,matAffine,(width,height))
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （三十三）
    #图片旋转
    import cv2
    import numpy as np
    img=cv2.imread('d://img/0.jpg',1)
    cv2.imshow('src',img)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #图片旋转 2*3
    matRotate=cv2.getRotationMatrix2D((height*0.5,width*0.5),45,0.5)#mat rotate 1 center 2 angle 3
    #100*100 25 
    dst=cv2.warpAffine(img,matRotate,(height,width))
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （三十四）
    #图片特效
    #特效1：灰度处理
    #特效2:底板效果
    #特效3：马赛克
    #特效4;毛玻璃效果
    #特效5：图像融合
    #特效6：图片蓝色
    #特效7：边缘检测
    #特效8：浮雕效果
    （三十五）
    #灰度处理Gray=(R+G+B)/3 Gray=R*0.299+G*0.587+B*0.114
    #底板效果（灰度） dst[i,j]=255-grayPixel
    #毛玻璃效果：随机像素
    #imread
    #方法1 imread
    import cv2
    img0=cv2.imread('d://img//0.jpg',0)
    img1=cv2.imread('d://img//0.jpg',1)
    print(img0.shape)
    print(img1.shape)
    cv2.imshow('src',img0)
    cv2.waitKey(0)
    （三十六）
    #方法 cvtcolor
    import cv2
    img=cv2.imread('d://img//0.jpg',1)
    dst=cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)#颜色空间转换1 data 2 BGR
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （三十七）
    #方法 cvtcolor
    import cv2
    img=cv2.imread('d://img//0.jpg',1)
    dst=cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)#颜色空间转换1 data 2 BGR
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （三十八）
    #方法3
    import cv2
    import numpy as np
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #RGB R=G=B=gray((R+G+B)/3)
    dst=np.zeros((height,width,3),np.uint8)
    for i in range(0,height):
        for j in range(0,width):
            (b,g,r)=img[i,j]
            gray=(int(b)+int(g)+int(r))/3
            dst[i,j]=np.uint8(gray)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （三十九）
    #方法3
    import cv2
    import numpy as np
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #RGB R=G=B=gray((R+G+B)/3)
    dst=np.zeros((height,width,3),np.uint8)
    for i in range(0,height):
        for j in range(0,width):
            (b,g,r)=img[i,j]
            gray=(int(b)+int(g)+int(r))/3
            dst[i,j]=np.uint8(gray)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十）
    #方法4
    #gray=r*0.299+g*0.587+b*0.114
    import cv2
    import numpy as np
    img=cv2.imread("d://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    dst=np.zeros((height,width,3),np.uint8)
    for i in range(0,height):
        for j in range(0,width):
            (b,g,r)=img[i,j]
            gray=r*0.299+g*0.5877+b*0.114
            dst[i,j]=np.uint8(gray)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十一）
    #算法优化
    # 1 灰度特效 最重要 2 基础 3实时性
    #定点运算 浮点 +-*/   >>
    #浮点转换为定点
    #(r*0.299*4+g*0.587*4+b*0.114*4)/4
    #100 1000 10000乘以的数值越大 优化越好
    import cv2
    import numpy as np
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #RGB R=G=B=gray((R+G+B)/3)
    dst=np.zeros((height,width,3),np.uint8)
    for i in range(0,height):
        for j in range(0,width):
            (b,g,r)=img[i,j]
            b=int(b)
            g=int(g)
            r=int(r)
    #         gray=(r*1+g*2+b*1)/4
            #左移两位表示 *4 右移两位表示 /4
            gray=(r+g<<2+b)/>>2
            dst[i,j]=np.uint8(gray)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十一）
    #RGB 255-R=newR
    #彩色图像的颜色反转
    #0-255 255-当前
    import cv2
    import numpy as np
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    dst=np.zeros((height,width,3),np.uint8)
    for i in range(0,height):
        for j in range(0,width):
            (b,g,r)=img[i,j]
            dst[i,j]=(255-b,255-g,255-r)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十二）
    #马赛克效果
    import cv2
    import numpy as np
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    for m in range(100,300):
        for n in range(100,200):
            #pixel->10*10
            if m%10==0 and n%10==0:
                for i in range(0,10):
                    for j in range(0,10):
                        (b,g,r)=img[m,n]
                        img[i+m,j+n]=(b,g,r)
    cv2.imshow('dst',img)
    cv2.waitKey(0)
    （四十三）
    import cv2
    import numpy as np
    import random
    img=cv2.imread("D://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    dst=np.zeros((height,width,3),np.uint8)
    mm=8
    for m in range(0,height-mm):
        for n in range(0,width-mm):
            index=int(random.random()*8)#0-8
            (b,g,r)=img[m+index,n+index]
            dst[m,n]=[b,g,r]
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十四）
    #图片融合
    #dst=src1*a+src2*(1-a)
    import cv2
    import numpy as np
    img0=cv2.imread("d://img//0.jpg",1)
    img1=cv2.imread("d://img//2.jpg",1)
    imgInfo=img0.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #ROI
    roiH=int(height/2)
    roiW=int(width/2)
    img0ROI=img0[0:roiH,0:roiW]
    img1ROI=img1[0:roiH,0:roiW]
    #dst
    dst=np.zeros((roiH,roiW,3),np.uint8)
    dst=cv2.addWeighted(img0ROI,0.5,img1ROI,0.5,0)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十五）
    #边缘检测 sobel
    #卷积运算
    # 实现方式一 直接调用API
    # 注意事项 边缘检测是基于灰度图像
    import cv2
    import numpy as np
    img=cv2.imread("d://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    #canny 1 gray 2 高斯滤波 3 canny 方法
    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    imgG=cv2.GaussianBlur(gray,(3,3),0)
    dst=cv2.Canny(img,50,50)
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十六）
    # 实现 二
    # sobel算子 代码方式
    # 前提知识
    # sobel算子
    # [1 2 1 [ 1 0 -1
    # 0 0 0 2 0 -2
    # -1 -2 -1 ] 1 0 -1]
    # 图片卷积 对应相乘再相加
    # [a b c d] [1 2 3 4] =a1+b2+c3+d4
    # 梯度方向 sqrt（aa+bb）
    import cv2
    import numpy as np
    import random
    import math
    img=cv2.imread('d://img//0.jpg',1)
    imginfo=img.shape
    height=imginfo[0]
    width=imginfo[1]
    cv2.imshow('src',img)
    # sobel 1 算子模板 2 图片卷积 3 阈值判决
    #  竖直 [ 1  2  1         水平  [ 1 0  -1
    #         0  0  0                 2 0  -2
    #       -1  -2 -1]                1 0  -1]
    #[1 2 3 4 ] [a b c d] =a*1+b*2+c*3+d*4 =dst
    #梯度方向 sqrt(a*a+b*b) =f(幅值) > th 
    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    dst=np.zeros((height,width,1),np.uint8)
    for i in range(0,height-2):
        for j in range(0,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)
            if grad>50:
                dst[i,j]=255
            else:
                dst[i,j]=0
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十七）
    #浮雕效果
    # 浮雕和边缘检测实现方法类似
    # newp=gray0-gray1+150
    # 相邻两像素的差值加上一个常数
    import cv2
    import numpy as np
    img=cv2.imread("d://img//0.jpg",1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    #newP=gray0-gray1+150
    dst=np.zeros((height,width,1),np.uint8)
    for i in range(0,height):
        for j in range(0,width-1):
            grayP0=int(gray[i,j])
            grayP1=int(gray[i,j+1])
            newP=grayP0-grayP1+150
            if newP>255:
                newP=255
            if newP<0:
                newP=0
            dst[i,j]=newP
    cv2.imshow('dst',dst)
    cv2.waitKey(0)
    （四十八）
    #颜色映射
    import cv2
    import numpy as np
    img=cv2.imread('d://img//0.jpg',1)
    imgInfo=img.shape
    height=imgInfo[0]
    width=imgInfo[1]
    dst=np.zeros((height,width,3),np.uint8)
    for i in range(0,height):
        for j in range(0,width):
            (b,g,r)=img[i,j]
            b=b*1.5
            g=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)
    （四十八）
    # 油画特效
    # 彩色图片转化成灰度
    # 划分若干小块 7*7
    # 将 0-255 划分为不同的等级
    # 求方块中灰度等级最多的像素，并求该像素的平均值
    # 用4中均值代替原来的像素
    import cv2
    import numpy as np
    img=cv2.imread('d:/img/0.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(0,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)