精华内容
下载资源
问答
  • 直方图规定化应用:举个例子,当我们需要对多张图像进行拼接时,我们希望这些图片的亮度、饱和度保持一致,事实上就是让它们的直方图分布一致,这时就需要直方图规定化直方图规定化与均衡化的思想一致,事实上就是...

    以下内容需要直方图均衡化、规定化知识

    直方图均衡化应用:

    图像直方图均衡化能拉伸灰度图,让像素值均匀分布在0,255之间,使图像看起来不会太亮或太暗,常用于图像增强;

    直方图规定化应用:

    举个例子,当我们需要对多张图像进行拼接时,我们希望这些图片的亮度、饱和度保持一致,事实上就是让它们的直方图分布一致,这时就需要直方图规定化。

    直方图规定化与均衡化的思想一致,事实上就是找到各个灰度级别的映射关系。具体实现的过程中一般会选一个参考图像记为A,找到A的直方图与目标图像的直方图的映射关系,从而找到目标图像的像素以A为“参考”时的映射关系。

    具体实现可参考文中链接(看完茅塞顿开)

    基于python利用直方图规定化统一图像风格

    参考图像

    原始图像(第一行)/处理后的图像(第二行)

    源码:

    import os

    import cv2

    import numpy as np

    def get_map(Hist):

    # 计算概率分布Pr

    sum_Hist = sum(Hist)

    Pr = Hist/sum_Hist

    # 计算累计概率Sk

    Sk = []

    temp_sum = 0

    for n in Pr:

    temp_sum = temp_sum + n

    Sk.append(temp_sum)

    Sk = np.array(Sk)

    # 计算映射关系img_map

    img_map = []

    for m in range(256):

    temp_map = int(255*Sk[m] + 0.5)

    img_map.append(temp_map)

    img_map = np.array(img_map)

    return img_map

    def get_off_map(map_): # 计算反向映射,寻找最小期望

    map_2 = list(map_)

    off_map = []

    temp_pre = 0 # 如果循环开始就找不到映射时,默认映射为0

    for n in range(256):

    try:

    temp1 = map_2.index(n)

    temp_pre = temp1

    except BaseException:

    temp1 = temp_pre # 找不到映射关系时,近似取向前最近的有效映射值

    off_map.append(temp1)

    off_map = np.array(off_map)

    return off_map

    def get_infer_map(infer_img):

    infer_Hist_b = cv2.calcHist([infer_img], [0], None, [256], [0,255])

    infer_Hist_g = cv2.calcHist([infer_img], [1], None, [256], [0,255])

    infer_Hist_r = cv2.calcHist([infer_img], [2], None, [256], [0,255])

    infer_b_map = get_map(infer_Hist_b)

    infer_g_map = get_map(infer_Hist_g)

    infer_r_map = get_map(infer_Hist_r)

    infer_b_off_map = get_off_map(infer_b_map)

    infer_g_off_map = get_off_map(infer_g_map)

    infer_r_off_map = get_off_map(infer_r_map)

    return [infer_b_off_map, infer_g_off_map, infer_r_off_map]

    def get_finalmap(org_map, infer_off_map): # 计算原始图像到最终输出图像的映射关系

    org_map = list(org_map)

    infer_off_map = list(infer_off_map)

    final_map = []

    for n in range(256):

    temp1 = org_map[n]

    temp2 = infer_off_map[temp1]

    final_map.append(temp2)

    final_map = np.array(final_map)

    return final_map

    def get_newimg(img_org, org2infer_maps):

    w, h, _ = img_org.shape

    b, g ,r =cv2.split(img_org)

    for i in range(w):

    for j in range(h):

    temp1 = b[i,j]

    b[i,j] = org2infer_maps[0][temp1]

    for i in range(w):

    for j in range(h):

    temp1 = g[i,j]

    g[i,j] = org2infer_maps[1][temp1]

    for i in range(w):

    for j in range(h):

    temp1 = r[i,j]

    r[i,j] = org2infer_maps[2][temp1]

    newimg = cv2.merge([b,g,r])

    return newimg

    def get_new_img(img_org, infer_map):

    org_Hist_b = cv2.calcHist([img_org], [0], None, [256], [0,255])

    org_Hist_g = cv2.calcHist([img_org], [1], None, [256], [0,255])

    org_Hist_r = cv2.calcHist([img_org], [2], None, [256], [0,255])

    org_b_map = get_map(org_Hist_b)

    org_g_map = get_map(org_Hist_g)

    org_r_map = get_map(org_Hist_r)

    org2infer_map_b = get_finalmap(org_b_map, infer_map[0])

    org2infer_map_g = get_finalmap(org_g_map, infer_map[1])

    org2infer_map_r = get_finalmap(org_r_map, infer_map[2])

    return get_newimg(img_org, [org2infer_map_b, org2infer_map_g, org2infer_map_r])

    if __name__ == "__main__":

    dstroot = './imgs'

    infer_img_path = './abc.png'

    infer_img = cv2.imread(infer_img_path)

    outroot = './out1'

    infer_map = get_infer_map(infer_img) # 计算参考映射关系

    dstlist = os.listdir(dstroot)

    for n in dstlist:

    img_path = os.path.join(dstroot, n)

    print(img_path)

    img_org = cv2.imread(img_path)

    new_img = get_new_img(img_org, infer_map) # 根据映射关系获得新的图像

    new_path = os.path.join(outroot, n)

    cv2.imwrite(new_path, new_img)

    展开全文
  • 首先是opencv在图像处理...老师要求的是在hsv模型里对直方图进行规定化,所以如果你是在rgb模型下进行直方图规定化,只需要将rgb和hsv互相转化的部分删除即可,重点并不是这里。import cv2import numpy as npfrom ...

    首先是opencv在图像处理方面的基础应用,彩色图像的相关知识和技术以及直方图的均衡化和规定化的原理是必须提前掌握,这些我就不做过多的介绍了。 本次实验也是基于python下完成的。

    老师要求的是在hsv模型里对直方图进行规定化,所以如果你是在rgb模型下进行直方图规定化,只需要将rgb和hsv互相转化的部分删除即可,重点并不是这里。

    import cv2

    import numpy as np

    from matplotlib import pyplot as plt

    img1 = cv2.imread('E:\\picSource\\Fig7A.jpg')

    img2 = cv2.imread('E:\\picSource\\Fig7B.jpg')

    img_hsv1 = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV) # bgr转hsv

    img_hsv2 = cv2.cvtColor(img2, cv2.COLOR_BGR2HSV)

    color = ('h', 's', 'v')

    for i, col in enumerate(color):

    # histr = cv2.calcHist([img_hsv1], [i], None, [256], [0, 256])

    hist1, bins = np.histogram(img_hsv1[:, :, i].ravel(), 256, [0, 256])

    hist2, bins = np.histogram(img_hsv2[:, :, i].ravel(), 256, [0, 256])

    cdf1 = hist1.cumsum() # 灰度值0-255的累计值数组

    cdf2 = hist2.cumsum()

    cdf1_hist = hist1.cumsum() / cdf1.max() # 灰度值的累计值的比率

    cdf2_hist = hist2.cumsum() / cdf2.max()

    diff_cdf = [[0 for j in range(256)] for k in range(256)] # diff_cdf 里是每2个灰度值比率间的差值

    for j in range(256):

    for k in range(256):

    diff_cdf[j][k] = abs(cdf1_hist[j] - cdf2_hist[k])

    lut = [0 for j in range(256)] # 映射表

    for j in range(256):

    min = diff_cdf[j][0]

    index = 0

    for k in range(256): # 直方图规定化的映射原理

    if min > diff_cdf[j][k]:

    min = diff_cdf[j][k]

    index = k

    lut[j] = ([j, index])

    h = int(img_hsv1.shape[0])

    w = int(img_hsv1.shape[1])

    for j in range(h): # 对原图像进行灰度值的映射

    for k in range(w):

    img_hsv1[j, k, i] = lut[img_hsv1[j, k, i]][1]

    hsv_img1 = cv2.cvtColor(img_hsv1, cv2.COLOR_HSV2BGR) # hsv转bgr

    hsv_img2 = cv2.cvtColor(img_hsv2, cv2.COLOR_HSV2BGR)

    cv2.namedWindow('firstpic', 0)

    cv2.resizeWindow('firstpic', 670, 900)

    cv2.namedWindow('targetpic', 0)

    cv2.resizeWindow('targetpic', 670, 900)

    cv2.namedWindow('defpic', 0)

    cv2.resizeWindow('defpic', 670, 900)

    cv2.imshow('firstpic', img1)

    cv2.imshow('targetpic',img2)

    # cv2.imshow('img1', img_hsv1)

    cv2.imshow('defpic', hsv_img1)

    cv2.waitKey(0)

    cv2.destroyAllWindows()

    以下分别是原图像 目标图像 和 经过直方图规定化后的图像:

    展开全文
  • 参考自:数字图像处理第三版,冈萨雷斯图像处理基础(8):图像的灰度直方图、直方图均衡化、直方图规定化(匹配) - Brook_icv - 博客园 https://www.cnblogs.com/wangguchangqing/p/7098213.html直方图规定化,又叫...

    参考自:

    数字图像处理第三版,冈萨雷斯

    图像处理基础(8):图像的灰度直方图、直方图均衡化、直方图规定化(匹配) - Brook_icv - 博客园 https://www.cnblogs.com/wangguchangqing/p/7098213.html

    直方图规定化,又叫直方图匹配。理想情况下,直方图均衡化实现了图像灰度的均衡分布,提高了图像对比度、提升了图像亮度。在实际应用中,有时并不需要图像的直方图具有整体的均匀分布,而希望直方图与规定要求的直方图一致,这就是直方图规定化。

    通过一个灰度映像函数,将原灰度直方图改造成所希望的直方图,把图像变换为某一特定的灰度分布,也就是其目的的灰度直方图是已知的。这其实和均衡化很类似,均衡化后的灰度直方图也是已知的,是一个均匀分布的直方图;而规定化后的直方图可以随意的指定,也就是在执行规定化操作时,首先要知道变换后的直方图,这样才能确定变换函数。规定化操作能够有目的的增强某个灰度区间,相比于,均衡化操作,规定化多了一个输入,但是其变换后的结果也更灵活。

    在理解了上述的均衡化过程后,直方图的规定化也较为简单。可以利用均衡化后的直方图作为一个中间过程,然后求取规定化的变换函数。具体步骤如下:

    将原始图像的灰度直方图进行均衡化,得到一个变换函数s=T(r),其中s是均衡化后的像素,r是原始像素

    对规定的直方图进行均衡化,得到一个变换函数v=G(z)v=G(z),其中v是均衡化后的像素,z是规定化的像素

    上面都是对同一图像(变换前的待规定化图像和变换后的规定化结果图像)的均衡化,其结果应该是相等的,s=v,且z=G−1(v)=G−1(T(r)),这个公式就是r和z的关系

    通过,均衡化作为中间结果,将得到原始像素 r 和 z 规定化后像素之间的映射关系。

    详解规定化过程

    对图像进行直方图规定化操作,原始图像的直方图和以及规定化后的直方图是已知的。

    假设Pr(r)表示原始图像的灰度概率密度,Pz(z)表示规定化图像的灰度概率密度(r和z分别是原始图像的灰度级,规定化后图像的灰度级)。

    对原始图像进行均衡化操作,则有

    对规定化的直方图进行均衡化操作,则

    由于是对同一图像的均衡化操作,所以有

    规定化操作的目的就是找到原始图像的像素sk到规定化后图像像素的zm之间的一个映射。

    有了上一步的等式后,可以得到sk=G(zm),因此要想找到sk对应的zm只需要在z进行迭代,找到使式子G(zm)−sk的绝对值最小即可。

    上述描述只是理论的推导过程,在实际的计算过程中,不需要做两次的均衡化操作,具体的推导过程如下:

    上面公式表示,假如sk规定化后的对应灰度是zm的话,需要满足的条件是sk的累积概率和zm的累积概率是最接近的

    下面是一个具体计算的例子:

    首先得到原直方图的各个灰度级的累积概率Vs以及规定化后直方图的各个灰度级的累积概率Vz,那么确定sk到zm之间映射关系的条件就是:

    ∣Vs−Vz∣的值最小。

    以k=2为例,其原始直方图的累积概率是:0.65,在规定化后的直方图的累积概率中和0.65最接近(相等)的是灰度值为5的累积概率密度,则可以得到原始图像中的灰度级2,在规定化后的图像中的灰度级是5。

    直方图规定化的实现

    直方图规定化的实现可以分为一下三步:

    计算原图像的累积直方图

    计算规定直方图的累积直方图

    计算两累积直方图的差值的绝对值

    根据累积直方图差值建立灰度级的映射

    具体代码

    """直方图规定化,又叫直方图匹配"""

    importnumpy as npimportmatplotlib.pyplot as pltimportcv2#定义函数,计算直方图累积概率

    defhistCalculate(src):

    row, col=np.shape(src)

    hist= np.zeros(256, dtype=np.float32) #直方图

    cumhist = np.zeros(256, dtype=np.float32) #累积直方图

    cumProbhist = np.zeros(256, dtype=np.float32) #累积概率probability直方图,即Y轴归一化

    for i inrange(row):for j inrange(col):

    hist[src[i][j]]+= 1cumhist[0]=hist[0]for i in range(1, 256):

    cumhist[i]= cumhist[i-1] +hist[i]

    cumProbhist= cumhist/(row*col)returncumProbhist#定义函数,直方图规定化

    def histSpecification(specImg, refeImg): #specification image and reference image

    spechist = histCalculate(specImg) #计算待匹配直方图

    refehist = histCalculate(refeImg) #计算参考直方图

    corspdValue = np.zeros(256, dtype=np.uint8) #correspond value

    #直方图规定化

    for i in range(256):

    diff= np.abs(spechist[i] -refehist[i])

    matchValue=ifor j in range(256):if np.abs(spechist[i] - refehist[j])

    diff= np.abs(spechist[i] -refehist[j])

    matchValue=j

    corspdValue[i]=matchValue

    outputImg=cv2.LUT(specImg, corspdValue)returnoutputImg

    img= cv2.imread('F:\program_study\Python\data\city.tif', cv2.IMREAD_GRAYSCALE)#读入参考图像

    img1 = cv2.imread('F:\program_study\Python\data\Lena.tif', cv2.IMREAD_GRAYSCALE)

    cv2.imshow('input', img)

    cv2.imshow('refeImg', img1)

    imgOutput=histSpecification(img, img1)

    cv2.imshow('output', imgOutput)

    cv2.waitKey(0)

    cv2.destroyAllWindows()

    fig= plt.figure('整个过程直方图显示', (8, 8))

    plt.subplot(311)

    plt.plot(histCalculate(img),'r', lw=1, label='待匹配累积概率直方图')

    plt.legend(loc='best')

    plt.subplot(312)

    plt.plot(histCalculate(img1),'b', lw=1, label='参考累积概率直方图')

    plt.legend(loc='best')

    plt.subplot(313)

    plt.plot(histCalculate(imgOutput),'g', lw=1, label='规则化后的概率直方图')

    plt.legend(loc='best')

    plt.show()

    局部的直方图处理

    除了全局的直方图处理外,还有局部直方图处理。它可以增前图像中小区域的细节。过程是定义一个领域模板,并将模板中心从一个像素移至另一个像素。在每个位置,计算领域中的点的直方图,均衡化或规定化,并将局部的中心元素的作为图像的当前值。

    展开全文
  • import torchdef torch_equalize(image):"""Implements Equalize function from PIL using PyTorch ops based on:...

    import torch

    def torch_equalize(image):

    """Implements Equalize function from PIL using PyTorch ops based on:https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py#L352"""

    def scale_channel(im, c):

    """Scale the data in the channel to implement equalize."""

    im = im[:, :, c]

    # Compute the histogram of the image channel.

    histo = torch.histc(im, bins=256, min=0, max=255)#.type(torch.int32)

    # For the purposes of computing the step, filter out the nonzeros.

    nonzero_histo = torch.reshape(histo[histo != 0], [-1])

    step = (torch.sum(nonzero_histo) - nonzero_histo[-1]) // 255

    def build_lut(histo, step):

    # Compute the cumulative sum, shifting by step // 2

    # and then normalization by step.

    lut = (torch.cumsum(histo, 0) + (step // 2)) // step

    # Shift lut, prepending with 0.

    lut = torch.cat([torch.zeros(1), lut[:-1]])

    # Clip the counts to be in range. This is done

    # in the C code for image.point.

    return torch.clamp(lut, 0, 255)

    # If step is zero, return the original image. Otherwise, build

    # lut from the full histogram and step and then index from it.

    if step == 0:

    result = im

    else:

    # can't index using 2d index. Have to flatten and then reshape

    result = torch.gather(build_lut(histo, step), 0, im.flatten().long())

    result = result.reshape_as(im)

    return result.type(torch.uint8)

    # Assumes RGB for now. Scales each channel independently

    # and then stacks the result.

    image = image.type(torch.float)

    s1 = scale_channel(image, 0)

    s2 = scale_channel(image, 1)

    s3 = scale_channel(image, 2)

    image = torch.stack([s1, s2, s3], 2)

    return image

    def find_nearest_above(my_array, target):

    diff = my_array - target

    mask = diff <= -1

    # We need to mask the negative differences

    # since we are looking for values above

    if torch.all(mask):

    c = torch.abs(diff).argmin()

    return c # returns min index of the nearest if target is greater than any value

    masked_diff = diff.clone()

    masked_diff[mask] = 9999

    return masked_diff.argmin()

    def hist_match(source, template):

    s = source.view(-1)

    t = template.view(-1)

    s_values, bin_idx, s_counts = torch.unique(s, return_inverse=True, return_counts=True)

    t_values, t_counts = torch.unique(t, return_counts=True)

    s_quantities = torch.cumsum(s_counts,0).type(torch.float)

    t_quantities = torch.cumsum(t_counts,0).type(torch.float)

    s_quantities = s_quantities/s_quantities[s_quantities.shape[0]-1]

    t_quantities = t_quantities/t_quantities[t_quantities.shape[0]-1]

    sour = (s_quantities * 255).type(torch.long)

    temp = (t_quantities * 255).type(torch.long)

    b = torch.zeros(sour.shape)

    for i in range(sour.shape[0]):

    b[i] = find_nearest_above(temp, sour[i])

    s=b[bin_idx]

    return s.view(source.shape)

    def hist_match_dark_prior(img):

    # input: img[h, w, c]

    # output:res[h, w, c]

    result = img.clone()

    result = torch_equalize(result)

    dark_prior,_ = torch.min(result, axis=2)

    for i in range(3):

    result[:,:,i] = hist_match(result[:,:,i], dark_prior)

    return result

    if __name__=='__main__':

    from PIL import Image

    import numpy as np

    im=Image.open("Night-schene-03.jpg")

    img=torch.from_numpy(np.array(im))

    img1=hist_match_dark_prior(img).numpy()

    im1=Image.fromarray(img1)

    im1.save('out.png')

    展开全文
  • 根据参考图像各个通道的灰度分布,将一副图像的灰度分布映射过去,使映射后的两幅图像灰度分布非常接近,被称为histogram matching或者histogram specification,常用于网络训练的图像数据扩增
  • 灰度直方图是图像中像素灰度集的一种统计反应。它能够描述图像中灰度的分布情况,直观地展现出图像中灰度所占多少。直方图横轴表示像素的灰度范围(比如说 0~255),纵轴表示的是像素的数量或者密度。亮暗、对比度、...
  • 所以我有两个问题:1-我有一个2D直方图w / 1D直方图沿着x& y轴.这些直方图总计了它们各自的x和y值,而主直方图总计了对数x-y区间的值.代码如下.我用pcolormesh来生成2D直方图……我已经生成了一个范围为vmin = 1,...
  • I am trying to understand what are the values of a 2D histogram.I have 2 numpy arrays of the same length X and Y (float numbers in each one).For example the first 10 values of X: [ 88, 193, 60, 98, .....
  • 直方图规定化应用:举个例子,当我们需要对多张图像进行拼接时,我们希望这些图片的亮度、饱和度保持一致,事实上就是让它们的直方图分布一致,这时就需要直方图规定化直方图规定化与均衡化的思想一致,事实上就是...
  • 直方图匹配又称为直方图规定化,是指将一幅图像的直方图变成规定形状的直方图而进行的图像增强方法。即将某幅影像或某一区域的直方图匹配到另一幅影像上。将图像的直方图分布规律与待匹配图像的脂肪分布规律近似。...
  • OpenCV python 彩色图像的直方图规定化

    千次阅读 2018-12-17 21:38:50
    首先是opencv在图像处理方面...老师要求的是在hsv模型里对直方图进行规定化,所以如果你是在rgb模型下进行直方图规定化,只需要将rgb和hsv互相转化的部分删除即可,重点并不是这里。 import cv2 import numpy as n...
  • 直方图均衡是将灰度值分布动态范围偏小的图像(如灰度值集中在直方图右部,此时图像过于明亮)扩大其动态范围,改变后的图像的灰度级数有可能降低。灰度统计直方图是一个1-D的离散函数,表达式为: 其中nk为在k...
  • 目录1 原理1.1 色彩模型转换原理1.2 灰度直方图绘制原理1.3 直方图均衡化原理1.4 直方图规定化原理2 实现源代码2.1 MATLAB实现2.1.1 RGB转HSI2.1.2 HSI转RGB2.1.3 绘制灰度直方图2.1.4 直方图均衡化2.1.5 直方图规定...
  • 直方图匹配又称为直方图规定化,是指将一幅图像的直方图变成规定形状的直方图而进行的图像增强方法。即将某幅影像或某一区域的直方图匹配到另一幅影像上。将图像的直方图分布规律与待匹配图像的脂肪分布规律近似。...
  • import 再放一个pytorch版的:import
  • python图像处理:直方图规定化直方图匹配)

    千次阅读 多人点赞 2019-04-12 13:12:51
    写在前面 因为笔者数字图像处理的作业是要求用VB来做规定化...python并没有相关的函数来进行规定化,唯一一个有规定化代码的但是是需要付钱的,于是笔者就用python写了一个可以做灰度图像直方匹配的代码。 (一)...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 直方图匹配(规定化) 连续灰度 s=T(r)=(L−1)∫0rpr(w)dw(3.17) s = T(r) = (L-1) \int_{0}^{r} p_r(w) \text{d} w \tag{3.17} s=T(r)=(L−1)∫0r​pr​(w)dw(3.17) 定义关于变量zzz的一个函数GGG,它具有如下性质...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

python直方图规定化

python 订阅