精华内容
下载资源
问答
  • opencv-python阈值分割

    2020-07-11 18:32:32
    全局阈值分割` import numpy as np src = np.array([[123,234,68],[33,51,17],[48,98,234],[129,89,27],[45,167,134]]) src[src>150] = 255 src[src<=150] = 0 src 在图像处理中一般不处理原图 而是使用...

    全局阈值分割`

    import numpy as np
    src = np.array([[123,234,68],[33,51,17],[48,98,234],[129,89,27],[45,167,134]])
    src[src>150] = 255
    src[src<=150] = 0
    src
    

    在图像处理中一般不处理原图 而是使用ndarray的成员函数copy()

    阈值函数

    threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type )

    src 单通道矩阵

    dst 输出矩阵

    thresh 阈值

    maxval 图像二值化显示时 一般设置为255

    type 类型

    类型:

    • type = THRESH_BINARY

      值大于阈值时 把值变成maxval的值

    • type = THRESH_BINARY_INV

      值小于等于阈值时 把值变成maxval的值

    • 当类型为THRESH_OTSU和THRESH_TRIANGLE时 src只支持uchar类型 这是thresh也可以作为输出参数,即通过otsu和triangle 这两种算法自动计算出。一般这两种方法和THRESH_BINARY搭配使用。

    import cv2
    src = np.array([[123,234,68],[33,51,17],[48,98,234],[129,89,27],[45,167,134]],np.uint8)
    #手动设置阈值
    the = 150
    maxval = 255
    dst = cv2.threshold(src,the,maxval,cv2.THRESH_BINARY)
    #Otsu阈值处理
    otsuThe = 0
    otsuThe, dst_Otsu = cv2.threshold(src,otsuThe,maxval,cv2.THRESH_OTSU)
    print(otsuThe, dst_Otsu)
    
    #TRIANGLE 阈值处理
    triThe = 0
    triThe, dst_tri = cv2.threshold(src,triThe,maxval,cv2.THRESH_TRIANGLE+cv2.THRESH_BINARY_INV)
    print(triThe, dst_tri)
    

    在这里插入图片描述
    这两种方式分别自动计算出阈值 并返回阈值计算的结果

    局部阈值分割

    在理想情况下使用全局阈值是比较合理的,但是往往由于图像光照不均匀的等因素,
    全局阈值的效果是不理想的。
    在这种情况下,使用局部阈值(也叫自适应阈值)进行分割可以产生好的效果。

    局部阈值分割的核心也是计算阈值矩阵,比较常用的是后面提到的自适应阈值算法
    (又称移动平均值算法),是一种简单但是高效的局部阈值算法,
    其核心思想就是把每一个像素的邻域的平均值作为该位置的阈值

    • 直方图技术法

    一幅含有一个背景呈现明显对比的物体的图像具有包含双峰的直方图,直方图技术法就是首先找到这两个峰值,然后取两个峰值之间的波谷位置对应的灰度值,就是所要的阈值。遗憾的是由于灰度在直方图中的随机波动,两个波峰(局部最大值)和它们之间的波谷都不能很好的确定,比如在两个峰值之间很可能会出现两个最小值,所以希望通过鲁棒的方法选定与最小值对应的阈值。一种常用的方法就是先对直方图进行高斯平滑处理,逐渐增大高斯滤波器的标准差, 直到能从平滑后的直方图中得到两个唯一的波峰和它们之间唯一的最小值。但这种方式需要手动调节,下面介绍一种规则自动选取波峰和波谷的方式。

    假设输入图像为I,高为H,宽为W,histogram_I代表其对应的灰度直方图,histogram_I_k代表灰度值等于k的像素点的个数,其中0<= k <=255

    • 第一步:
      找到灰度直方图的第一个峰值,并找到其对应的灰度值,记为firstPeak

    • 第二步:
      找到直方图的第二个峰值,并找到其对应的灰度值。第二个峰值不一定是直方图的第二大值,因为它很有可能会出现第一峰值的附近。可以用公式计算:

    secondPeak = argmax{(k-firstPeak)^2 * histogram_I_k}, 0< =k <=255

    也可以使用绝对值的形式:

    secondPeak = argmax{|k-firstPeak|*histogram_I_k}, 0< =k <=255

    • 第三步:
      找到这两个峰值之间的波谷,如果出现两个或多个波谷,则取左侧的波谷即可, 其对应的灰度值即为阈值
    #python实现
    #在利用直方图技术计算阈值时, 会计算一个直方图最大值的位置索引,
    #可利用Numpy提供的where函数,该函数的示例代码如下:
    
    import numpy as np
    hist = np.array([10,3,13,2,1,5])
    maxLoc = np.where(hist==np.max(hist))
    maxLoc
    

    在这里插入图片描述

    #如果出现多个最大值的情况
    import numpy as np
    hist = np.array([10,3,13,2,13,1,5])
    maxLoc = np.where(hist==np.max(hist))
    maxLoc
    #对于一维数组 如果出现多个最大值 则返回为存储所有最大值索引的以为数组组成的元组
    

    在这里插入图片描述

    def calcGrayHist(I):
        #计算灰度直方图
        h, w = I.shape[:2]
        grayHist = np.zeros([256], np.uint64)
        for i in range(h):
            for j in range(w):
                grayHist[I[i][j]] += 1
        return grayHist
    def threshTwoPeaks(image):
        #计算灰度直方图
        histogram = calcGrayHist(image)
        #找到灰度直方图的最大值对应的灰度值
        maxLoc = np.where(histogram==np.max(histogram))
        firstPeak = maxLoc[0][0]
        #寻找灰度直方图的第二个峰值对应的灰度值
        measureDists = np.zeros([256], np.float32)
        for k in range(256):
            measureDists[k] = pow(k-firstPeak,2)*histogram[k]
        maxLoc2 = np.where(measureDists==np.max(measureDists))
        secondPeak = maxLoc2[0][0]
        #找到两个峰值之间的最小值对应的灰度值,作为阈值
        thresh = 0
        if firstPeak > secondPeak:#第一个峰值在第二个峰值的右侧
            temp = histogram[int(secondPeak):int(firstPeak)]
            minLoc = np.where(temp == np.min(temp))
            thresh = secondPeak + minLoc[0][0]+1
        else:#第一个峰值在第二个峰值的左侧
            temp = histogram[int(firstPeak):int(secondPeak)]
            minLoc = np.where(temp == np.min(temp))
            thresh = secondPeak + minLoc[0][0]+1
        #找到阈值后进行阈值处理 得到二值图
        threshImage_out = image.copy()
        threshImage_out[threshImage_out > thresh] = 255
        threshImage_out[threshImage_out < thresh] = 0
        return (thresh, threshImage_out)
    
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    img = cv2.imread('cat.jpg',0)
    thresh, img_dst = threshTwoPeaks(img)
    print('thresh is :',thresh)
    
    plt.figure(figsize=(20,20)) #设置窗口大小
    img_dog = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    plt.subplot(1,1,1), plt.title('b')
    plt.imshow(img_dog), plt.axis('off')
    
    plt.figure(figsize=(20,20)) #设置窗口大小
    dst_img = cv2.cvtColor(img_dst, cv2.COLOR_BGR2RGB)
    plt.subplot(1,1,1), plt.title('b')
    plt.imshow(dst_img), plt.axis('off')
    

    thresh is : 173
    在这里插入图片描述
    在这里插入图片描述
    在直方图中存在明显双峰的情况下,使用基于直方图计算得到的阈值效果很好,比较完整地分割出图中目标物体;
    否则使用这种方法分割后的效果并不理想,没有完整地分割出前景和背景,几乎分辨不清目标物体。

    • 熵算法(公式复杂不会手敲)
      信息熵的概念来源于信息论,假设信源符号u有N种取值,记为:

    u1,u2,…,uN。

    且每一种信源符号出现的概率,记为:

    p1,p2,…,pN

    那个该信号源的信息熵记为:

    entropy(u)= - sum(p_i*log(p_i)) 1<=i<=N

    图像也可以看作一种信源,假设输入图像为I,normHist_I代表归一化的图像灰度直方图,那么对于8位图可以看成有256个灰度符号,且每一个符号出现的概率为normHist_I(k)组成的信源, 其中0<=k<=255

    #采用熵算法进行阈值分割的python实现 
    #首先将计算得出的累加概率直方图和各个灰度级的熵分别保存到长度为256的ndarray种。
    #需要注意的是,在第二步的实现中,因为对数的自变量是不能等于0的,如果判断normHist_I(k)=0,
    #那么直接令entropy(k)=entropy(k-1)即可
    def threshEntroy(image):
        rows, cols = image.shape
        #求灰度直方图
        grayHist = calcGrayHist(image)
        #归一化灰度直方图 即概率直方图
        normGrayHist = grayHist/float(rows*cols)
        #第一步:计算累加直方图,也称零阶累计矩
        zeroCumuMoment = np.zeros([256], np.float32)
        for k in range(256):
            if k == 0:
                zeroCumuMoment[k] = normGrayHist[k]
            else:
                zeroCumuMoment[k] = zeroCumuMoment[k-1] + normGrayHist[k]
        #第二步: 计算各个灰度级的熵
        entropy = np.zeros([256], np.float32)
        for k in range(256):
            if k == 0:
                if normGrayHist[k] == 0:
                    entropy[k] = 0
                else:
                    entropy[k] = -normGrayHist[k]*math.log10(normGrayHist[k])
            else:
                if normGrayHist[k] == 0:
                    entropy[k] = entropy[k-1]
                else:
                    entropy[k] = entropy[k-1]-normGrayHist[k]*math.log10(normGrayHist[k])
        #第三步:找阈值
        fT = np.zeros([256], np.float32)
        ft1,ft2 = 0.0,0.0
        totalEntroy = entropy[255]
        for k in range(255):
            #找最大值
            maxFront = np.max(normGrayHist[0:k+1])
            maxBack = np.max(normGrayHist[k+1:256])
            if(maxFront == 0 or zeroCumuMoment[k] == 0 or maxFront == 1 or
              zeroCumuMoment[k] == 1 or totalEntroy == 0):
                ft1 = 0
            else:
                ft1 = entropy[k]/totalEntroy*(math.log10(zeroCumuMoment[k])/math.log10(maxFront))
            if(maxBack == 0 or 1-zeroCumuMoment[k] == 0 or maxBack == 1 or 1-zeroCumuMoment[k] == 1):
                ft2 = 0
            else:
                ft2 = (1-entropy[k]/totalEntroy)*(math.log10(1-zeroCumuMoment[k])/math.log10(maxBack))
            fT[k] = ft1+ft2
            #找出最大值的索引, 作为得到的阈值
            threshLoc = np.where(fT==np.max(fT))
            thresh = threshLoc[0][0]
            #阈值处理
            threshold = np.copy(image)
            threshold[threshold > thresh] = 255
            threshold[threshold <= thresh] = 0
            return threshold      
    
    import math
    img_ft = threshEntroy(img)
    plt.figure(figsize=(20,20)) #设置窗口大小
    img_ft = cv2.cvtColor(img_ft, cv2.COLOR_BGR2RGB)
    plt.subplot(1,1,1), plt.title('b')
    plt.imshow(img_ft), plt.axis('off')
    

    在这里插入图片描述
    从图中可以看出,所得到的效果并没有采用直方图技术进行阈值分割得到的效果有明显的提升,所以针对阈值分割选取什么样的方法需要分情况对待

    敲了这么多效果不好:淦

    • Otsu阈值处理

    在对图像进行阈值分割时,所选取的分割阈值应使前景区域的平均灰度,背景区域的平均灰度与整幅图像的平均灰度之间差异最大,这种差异用区域的方差来表示。
    Otsu提出了最大方差法,该算法是在判别分析最小二乘法原理的基础上推导出来的,计算过程简单是一种常用的阈值分割的稳定算法。

    • 第一步:计算灰度直方图的零阶累积矩(或称累加直方图)。
    • 第二步:计算灰度直方图的一阶累积矩
    • 第三步:计算图像总体的灰度平均值mean, 其实就是k = 255时时的一阶累积矩
    • 第四步:计算每一个灰度级作为阈值时, 前景区域的平均灰度, 背景区域的平均灰度 与整幅图像的平混灰度的方差。
    • 第五步: 找到上述最大的方差 然后独赢的k 即为Otsu 自动选取的阈值
    #实现Ostu阈值分割 
    #输入参数为8位图 返回值为由阈值分割结果和Ostu阈值组成的二元元组
    #注意 在求方差时 分母有可能出现0的情况
    def otsu(image):
        rows, cols = image.shape
        #计算图像的灰度直方图
        grayHist = calcGrayHist(image)
        #归一化灰度直方图
        uniformGrayHist = grayHist/float(rows*cols)
        #计算零阶累积矩和一阶累积矩
        zeroCumuMoment = np.zeros([256], np.float32)
        oneCumuMoment = np.zeros([256], np.float32)
        for k in range(256):
            if k == 0:
                zeroCumuMoment[k] = uniformGrayHist[0]
                oneCumuMoment[k] = k*uniformGrayHist[0]
            else:
                zeroCumuMoment[k] = zeroCumuMoment[k-1] + uniformGrayHist[k]
                oneCumuMoment[k] = zeroCumuMoment[k-1] + k*uniformGrayHist[k]
        #计算类间方差
        variance = np.zeros([256], np.float32)
        for k in range(255):
            if zeroCumuMoment[k] == 0 or zeroCumuMoment[k] == 1:
                variance[k] = 0
            else:
                variance[k] = math.pow(oneCumuMoment[255]*zeroCumuMoment[k] - oneCumuMoment[k],2)/(zeroCumuMoment[k]*(1.0-zeroCumuMoment[k]))
        #找到阈值
        threshLoc = np.where(variance[0:255] == np.max(variance[0:255]))
        thresh = threshLoc[0][0]
        #阈值处理
        threshold = np.copy(image)
        threshold[threshold > thresh] = 255
        threshold[threshold <= thresh] = 0
        return (threshold,thresh)
        
    
    img_otsu, thresh = otsu(img)
    print("thresh is:", thresh)
    plt.figure(figsize=(20,20)) #设置窗口大小
    img_otsu = cv2.cvtColor(img_otsu, cv2.COLOR_BGR2RGB)
    plt.subplot(1,1,1), plt.title('b')
    plt.imshow(img_otsu), plt.axis('off')
    

    thresh is: 251

    在这里插入图片描述

    • 自适应阈值

    在不均匀照明或者灰度值分布不均匀的情况下 如果使用全局阈值分割那么得到的分割效果往往会很不理想 。

    def adaptiveThresh(I, winSize, ratio=0.12):
        #第一步 对图像进行均值平滑
        I_mean = cv2.boxFilter(I, cv2.CV_32FC1, winSize)
        #第二步 原图像矩阵与平滑结果做差
        out = I - (1.0-ratio)*I_mean
        #第三步 当差值大于等于 0 时, 输出值为255;反之 输出为0
        out[out>=0] = 255
        out[out<0] = 0
        out = out.astype(np.uint8)
        return out
    
    dst_adap = adaptiveThresh(img, (35,35))
    plt.figure(figsize=(20,20)) #设置窗口大小
    dst_adap = cv2.cvtColor(dst_adap, cv2.COLOR_BGR2RGB)
    plt.subplot(1,1,1), plt.title('b')
    plt.imshow(dst_adap), plt.axis('off')
    

    在这里插入图片描述
    手撸书上的内容。
    有几个公式特别复杂 之后看有没有好的办法可以写出来。
    未允许,禁转载。

    展开全文
  • Opencv中提供了五种阈值分割的函数,将这五种函数均应用于源图像观察其效果。 图2 五种阈值分割函数作用于原图像img1 图3 阈值分割结果(左上为原图像) 发现第四种方法可以分割到完整的花瓣部分并保留...

    完整代码在最后。

    一、处理结果

    图1 原图像(左)和上色后图像(右)

     

    二、实现方法

    Opencv中提供了五种阈值分割的函数,将这五种函数均应用于源图像观察其效果。

    图2 五种阈值分割函数作用于原图像img1

    图3 阈值分割结果(左上为原图像)

     

           发现第四种方法可以分割到完整的花瓣部分并保留细节,第五种方法即第四种的取反可以分割到叶子的部分并保留细节。取这两种方法的结果,用mapcolor上色。

    图4 上色算法

    图5 两张图上色分开的结果

     

           将两张彩色图片做加法。得到的结果既有花的颜色也有背景的颜色。

    图6 图像相加

    图7 相加结果

     

    三、总结

           1.通过分开处理背景与花朵并分开上色再相加的方法可以给原灰度图像上色,但是由于阈值分割的结果中,被分割出的部分为黑色,颜色较深,因此融合结果会变暗,最好能够搭配提高亮度的算法优化结果,但由于有些复杂我还没有实现。

           2.可以发现,在阈值分割后图片中一些属于花的地方被认为是背景,尝试使用腐蚀算法,但由于腐蚀算法只能作用域二值化后的图像,而二值化会失去图像细节,因此并未将腐蚀后的结果上色。

    图8 腐蚀算法

    图9 腐蚀后结果

           3.在初期的尝试过程中,我曾尝试不使用colormap伪彩上色,通过直方图得出阈值后,对逐个像素进行判断,小于阈值94的部分上绿色,大于94的部分是红色,但这样得到的结果并不具有观赏性。

    图10 实现函数(其中blue实际上是red)

    图11 结果

     

    好看点的那个的代码:

    import cv2
    import numpy as np
    from matplotlib import pyplot as plt
    
    img_path = "C:/Users/Lenovo/PycharmProjects/color_flower/2.png"
    img1 = cv2.imread('2.png', cv2.IMREAD_GRAYSCALE)
    
    binary_path, th = cv2.threshold(img1, 180, 255, cv2.THRESH_BINARY)
    binary_inv_path, th1 = cv2.threshold(img1, 180, 255, cv2.THRESH_BINARY_INV)
    trunc_path, th2 = cv2.threshold(img1, 180, 255, cv2.THRESH_TRUNC)
    tozero_path, th3 = cv2.threshold(img1, 180, 255, cv2.THRESH_TOZERO)
    tozero_inv_path, th4 = cv2.threshold(img1, 180, 255, cv2.THRESH_TOZERO_INV)
    
    
    def erode_demo(gray):
        ret, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV)
        cv2.imshow("binary", binary)
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
        dst = cv2.erode(binary, kernel)
        return dst
    
    def dilate_demo(gray):
        ret, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV)
        cv2.imshow("binary", binary)
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
        dst = cv2.dilate(binary, kernel)
        return dst
    
    result = erode_demo(th3)
    result3 = dilate_demo(result)
    cv2.imshow('result', result)
    cv2.imshow('result3',result3)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    
    img_color = cv2.applyColorMap(th3, cv2.COLORMAP_HOT)
    img_color1 = cv2.applyColorMap(th4, cv2.COLORMAP_DEEPGREEN)
    
    Image = cv2.addWeighted(img_color, 0.3, img_color1, 0.7, 0)
    
    out_img1 = np.hstack((img1, th, th1))
    out_img2 = np.hstack((th2, th3, th4))
    out_img = np.vstack((out_img1, out_img2))
    
    cv2.imwrite("C:/Users/Lenovo/PycharmProjects/color_flower/out.png", out_img)
    cv2.imwrite("C:/Users/Lenovo/PycharmProjects/color_flower/out1.png", img_color)
    cv2.imwrite("C:/Users/Lenovo/PycharmProjects/color_flower/out2.png", img_color1)
    cv2.imwrite("C:/Users/Lenovo/PycharmProjects/color_flower/out3.png", Image)

    替换像素直接上色的代码:

    import cv2
    import matplotlib.pyplot as plt
    import numpy as np
    import math
    import os
    import pandas as pd
    from tqdm import tqdm
    
    # 绘制直方图函数
    '''def grayHist(img):
        h, w = img.shape[:2]
        pixelSequence = img.reshape([h * w, ])
        numberBins = 256
        histogram, bins, patch = plt.hist(pixelSequence, numberBins,facecolor='black', histtype='bar')
        plt.xlabel("gray label")
        plt.ylabel("number of pixels")
        plt.axis([0, 255, 0, np.max(histogram)])
        plt.show()
    
    image = cv2.imread("1.jpg",0)
    grayHist(image)'''
    
    
    color_dict = {"green": [34, 139, 34],
                  "blue": [255,0,255],
                  "pink": [203, 192, 255]}
    
    #img = cv2.imread('1.jpg')
    img = cv2.imread('../flower2/1.jpg', cv2.IMREAD_GRAYSCALE)
    #img_color = gray2rgb(gray , color_dict)
    
    def gray2rgb(gray, color_dict):
    
        # 1:创建新图像容器
        rgb_image = np.zeros(shape=(*gray.shape, 3))
        # 2: 遍历每个像素点
        for i in range(rgb_image.shape[0]):
            for j in range(rgb_image.shape[1]):
                # 3:对不同的灰度值选择不同的颜色
                if gray[i, j] < 92:
                    rgb_image[i, j, :] = color_dict["green"]
                elif gray[i, j] >= 92:
                    rgb_image[i, j, :] = color_dict["blue"]
    
    
        return rgb_image.astype(np.uint8)
    
    
    img_color = gray2rgb(img.astype(np.uint8), color_dict)
    cv2.imshow("colored", img_color)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    
    

     

    展开全文
  • @ 图像阈值分割(最大熵方法) 老规矩,看相关函数(哈哈,没有啥函数) 步骤 1.进行归一化直方图 2.累加概率直方图 3.求出各个灰度级的熵 4.计算最大熵时的阈值 计算公式 1.normHist为归一化的直方图,这里不做介绍...

    @ 图像阈值分割(最大熵方法)

    老规矩,看相关函数(哈哈,没有啥函数)

    步骤

    1.进行归一化直方图

    2.累加概率直方图

    3.求出各个灰度级的熵

    4.计算最大熵时的阈值

    计算公式
    1.normHist为归一化的直方图,这里不做介绍
    2.累加概率直方图
    在这里插入图片描述
    3.求出各个灰度级的熵
    在这里插入图片描述

    4.计算最大熵时的阈值计算:f(t)=f1(t)+f2(t)最大化的t值,该值即为得到的阈值,即thresh=argmax(f(t))
    在这里插入图片描述

    上代码

    #相关包
    import numpy as np
    import cv2
    import imutils
    import time
    import matplotlib.pyplot as plt
    from PIL import *
    from tensorflow.keras.preprocessing.image import img_to_array,array_to_img
    from skimage.filters import threshold_local
    
    path=r"C:\Users\Administrator\Desktop\22.jpg"
    # imag=img_to_array(Image.open(path).convert("L").resize((224,224)))
    # imag=Image.open(path).convert("L").resize((224,224))
    # plt.imshow(imag)
    # plt.show()
    imag=cv2.imdecode(np.fromfile(path),-1)
    imag=cv2.cvtColor(imag,cv2.COLOR_BGR2GRAY)
    cv2.imshow("a",imag)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    在这里插入图片描述

    直方图

    def calcGrayHist(image):
        rows, cols = image.shape
        grayHist = np.zeros([256])
        for r in range(rows):
            for c in range(cols):
                grayHist[int(image[r,c])] += 1
    
        return grayHist
     normgrayHist=calcGrayHist(np.array(imag))
    index = np.arange(256)
    plt.figure(figsize=(40,10))
    p2 = plt.bar(index, normgrayHist,label="threshold", color="g")
    # index=index.astype(np.int)
    # a=a.astype(np.int)
    for i,j in zip(index,normgrayHist):
        plt.text(i,j,'%.3f'%(j*10), ha = 'center',va = 'bottom',fontsize=11)
    plt.legend()
    # plt.imshow(p2)
    plt.show()
    
    

    在这里插入图片描述

    最大熵

    def threshEntroy(image):
        rows,cols=image.shape
        #获取直方图
        grayHist=calcGrayHist(image)
        #得到概率直方图
        normgrayHist=grayHist/float(rows*cols)
    
        zeroCumuMoment=np.zeros([256],np.float32)
        for k in range(256):
            if k==0:
                zeroCumuMoment[k]=normgrayHist[k]
            else:
                zeroCumuMoment[k]=zeroCumuMoment[k-1]+normgrayHist[k]
        entropy=np.zeros([256],np.float32)
        #计算熵
        for k in range(256):
            if k==0:
                if normgrayHist[k]==0:
                    entropy[k]=0
                else:
                    entropy[k]=-normgrayHist[k]*np.log10(normgrayHist[k])
            else:
                if normgrayHist[k]==0:
                    entropy[k]=entropy[k-1]
                else:
                    entropy[k]=entropy[k-1]-normgrayHist[k]*np.log10(normgrayHist[k])
                    
                    
        ft=np.zeros([256],np.float32)
        ft1,ft2=0.,0.
        totalEntropy=entropy[255]
        for k in range(255):
        #找最大值
            maxfornt=np.max(normgrayHist[:k+1])
            maxback=np.max(normgrayHist[k+1:256])
            if (maxfornt==0 or zeroCumuMoment[k]==0 or maxfornt==1 or zeroCumuMoment[k]==1 or totalEntropy==0):
                ft1=0
            else:
                ft1=entropy[k]/totalEntropy*(np.log10(zeroCumuMoment[k])/np.log10(maxfornt))
            if(maxback==0 or 1-zeroCumuMoment[k]==0 or maxback==1 or 1-zeroCumuMoment[k]==1):
                ft2=0
            else:
                if totalEntropy==0:
                    ft2=(np.log10(1-zeroCumuMoment[k])/np.log10(maxback))
                else:
                    ft2=(1-entropy[k]/totalEntropy)*(np.log10(1-zeroCumuMoment[k])/np.log10(maxback))
            ft[k]=ft1+ft2
      #找出最大值的索引,作为得到的阈值
        thresloc=np.where(ft==np.max(ft))
        thresh=thresloc[0][0]
    
        #阈值处理
        threshold=np.copy(image)
        threshold[threshold>thresh]=255
        threshold[threshold<=thresh]=0
        #返回分割图像,最大阈值,最大熵和熵
        return threshold,thresh,max(ft),entropy
    b,a,c,e=threshEntroy(np.array(imag))
    #结果显示
    #b=np.expand_dims(b,axis=-1)
    #d=array_to_img(b)
    
    # d.shape
    #plt.imshow(d)
    cv2.imshow("f",b)
    cv2.waitKey()
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • python OpenCV 阈值分割

    2020-06-23 20:15:21
    第四个参数:阈值分割方式 下面是阈值分割的五种不同方式: cv2.THRESH_BINARY(黑白二值) cv2.THRESH_BINARY_INV(黑白二值翻转) cv2.THRESH_TRUNC(得到额图像为多像素值) cv2.THRESH_TOZERO(当像素高于阈值时...
    ret,th1=cv2.threshold(img,127,255,cv2.THRESH_BINARY)
    

    第一个参数:图片
    第二个参数:阈值
    第三个参数:我们提供的一个值
    第四个参数:阈值分割方式

    下面是阈值分割的五种不同方式:
    cv2.THRESH_BINARY(黑白二值)
    cv2.THRESH_BINARY_INV(黑白二值翻转)
    cv2.THRESH_TRUNC(得到额图像为多像素值)
    cv2.THRESH_TOZERO(当像素高于阈值时像素设置为自己提供的像素值,低于阈值时不作处理)
    cv2.THRESH_TOZERO_INV(当像素低于阈值时设置为自己提供的像素值,高于阈值时不作处理)

    展开全文
  • 这篇文章将详细讲解图像分割知识,包括阈值分割、边缘分割、纹理分割、分水岭算法、K-Means分割、漫水填充分割、区域定位等。万字长文整理,希望对您有所帮助。 同时,该部分知识均为作者查阅资料撰写总结,并且开设...
  • 主要为大家详细介绍了python+opencv实现阈值分割的相关代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 第六节:阈值分割一: 全阈值分割 实例代码:image = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)the = 100 # 设置阈值为100maxval = 255dst, img = cv2.threshold(image, the, maxval, cv2.THRESH_BINARY)cv2....
  • 引言由于笔者从事二分类问题的研究,另外实验室也有此类算法的实现需要,因此从该文开始,笔者将连续讲解基于Python封装函数进行遥感图像特征的分割方法与实现。本文将以NDVI特征为例,进行农田环境下建筑物的分割。...
  • python+openCV 自适应阈值分割

    千次阅读 2019-04-26 17:03:16
    当图像各局部亮度不同时,全局阈值就很难将背景和目标分割。因此提出了自适应阈值,即在图像的不同区域采用不同的阈值进行分割。利用函数cv2.adaptiveThreshold()进行分割。 cv2.adaptiveThreshold(src, maxValue...
  • 阈值分割python实现

    千次阅读 2019-09-28 18:01:43
    4、自适应阈值分割 import cv2 import numpy as np from scipy import signal import math def calcGrayHist(image): rows,cols=image.shape grayHist=np.zeros([256],np.uint64) for r in range(rows): for c...
  • 第六节:阈值分割 一: 全阈值分割 实例代码: image = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE) the = 100 # 设置阈值为100 maxval = 255 dst, img = cv2.threshold(image, the, maxval, cv2.THRESH_...
  • 1.直方图阈值:使用与双峰图像
  • Python+opencv 阈值分割

    2020-12-06 15:09:20
    import cv2 import matplotlib.pyplot as plt import matplotlib # 设置画图支持中文 font = {'family': 'SimHei'} matplotlib.rc('font', **font) # 图像路径 ...# 二进制阈值化 _, a = cv2.threshol

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,394
精华内容 4,557
关键字:

python阈值分割

python 订阅