精华内容
下载资源
问答
  • 目录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 直方图规定...

    1 原理

    1.1 色彩模型转换原理

    RGB转HSI利用以下公式:
    在这里插入图片描述

    HSI转RGB利用以下公式:
    (1)H在[0, 2/3π]之间:
    在这里插入图片描述

    (2)H在[2/3π, 4/3π]之间:
    在这里插入图片描述

    (3)H在[4/3π,5/3π ]之间:
    在这里插入图片描述

    因此,遍历图像中每一个像素(或者直接使用矩阵运算),对每个像素点按公式进行计算即可。

    1.2 灰度直方图绘制原理

    • 灰度直方图是灰度级的函数,它表示图像中具有每种灰度级的像素的个数,反映图像中每种灰度出现的频率。
    • 灰度直方图的横坐标是灰度级,纵坐标是该灰度级出现的频率,它是图像基本的统计特征。

    因此,遍历图像中每一个像素,记录每个像素的灰度值(彩色图像记录转换为HSI色彩空间后的亮度通道值),累加统计。而后以灰度级为横坐标,灰度级出现频次或频率为纵坐标绘图即可。

    1.3 直方图均衡化原理

    直方图均衡化就是把原始图像的直方图变换为均匀分布的形式,以增加像素灰度值的动态范围,增加图像整体的对比度效果。过程可以归纳如下(参考自王科平《数字图像处理 MATLAB版》):
    在这里插入图片描述

    1.4 直方图规定化原理

    直方图规定化可以有选择性地增强某个灰度值范围内的对比度,或者使图像灰度值的分布满足特定的要求。主要有三个步骤:
    在这里插入图片描述

    可以认为是,将原始图像和需要的直方图均进行直方图均衡化后,两个均衡化后的结果对应上的部分,将其均衡化前的灰度值对应,形成原始图像和需要的直方图间的映射。用此映射去处理图像中的每一个像素即可。

    2 实现源代码

    2.1 MATLAB实现

    2.1.1 RGB转HSI

    function hsi=rgb2hsi(img)
    % e.g.
    %   img=imread('color.jpg');
    %   hsi=rgb2hsi(img);
    %   rgb=hsi2rgb(img);
    rows=length(img(:,1));
    cols=length(img(1,:)) / length(img(1,1,:));
    img=im2double(img);
    hsi=img;
    for i=1:rows
        for j=1:cols
            % get r g b
            r=img(i,j,1);
            g=img(i,j,2);
            b=img(i,j,3);
            % cal h
            num=0.5*((r-g)+(r-b));
            den=sqrt(power(r-g,2)+(r-b)*(g-b));
            theta=acos(num/(den+eps));
            if b<=g
                hsi(i,j,1)=theta;
            else
                hsi(i,j,1)=2*pi-theta;
            end
            % cal s
            if r+g+b==0
                hsi(i,j,2)=1-3*min(min(r,g),b)/(r+g+b+eps);
            else
                hsi(i,j,2)=1-3*min(min(r,g),b)/(r+g+b);
            end
            if hsi(i,j,2)==0
                hsi(i,j,1)=0;
            end
            % cal i
            hsi(i,j,3)=1/3*(r+g+b);
        end
    end
    hsi=im2uint8(hsi);
    
    

    2.1.2 HSI转RGB

    function rgb=hsi2rgb(img)
    % e.g.
    %   img=imread('color.jpg');
    %   hsi=rgb2hsi(img);
    %   rgb=hsi2rgb(img);
    rows=length(img(:,1));
    cols=length(img(1,:)) / length(img(1,1,:));
    img=im2double(img);
    rgb=img;
    for k=1:rows
        for j=1:cols
            % get h s i
            h=img(k,j,1);
            s=img(k,j,2);
            i=img(k,j,3);
            % set r g b
            r=0;
            g=0;
            b=0;
            if 0 <=h<=2/3*pi
                b=i*(1-s);
                r=i*(1+s*cos(h)/cos(pi/3-h));
                g=3*i-(b+r);
            elseif 2/3*pi<h<=4/3*pi
                r=i*(1-s);
                g=i*(1+s*cos(h-2/3*pi)/cos(pi-h));
                b=3*i-(r+g);
            elseif 4/3*pi<h<=5/3*pi
                g=i*(1-s);
                b=i*(1+s*cos(h-4/3*pi)/cos(5/3*pi-h));
                r=3*i-(g+b);
            end
            rgb(k,j,1)=r;
            rgb(k,j,2)=g;
            rgb(k,j,3)=b;
        end
    end
    rgb=im2uint8(rgb);
    

    2.1.3 绘制灰度直方图

    function frequency=drawgrayscalehistogram(img,filename)
    % e.g.
    %   img=imread('color.jpg');
    %   filename='color';
    %   frequency=drawgrayscalehistogram(img,filename);
    img=im2uint8(img);
    rows=length(img(:,1));
    cols=length(img(1,:))/length(img(1,1,:));
    frequency=zeros(1,256);
    for i=1:rows
        for j=1:cols
            % Matlab number starts from 1
            temp_grayscale=abs(img(i,j,3))+1;
            frequency(temp_grayscale)=frequency(temp_grayscale)+1;
        end
    end
    ind=0:255;
    h=figure;
    bar(ind,frequency);
    title([filename,' grayscale histogram']);
    xlabel('grayscale');
    ylabel('frequency');
    saveas(h, [filename,'_grayscale_histogram'],'png');
    close(h);
    

    2.1.4 直方图均衡化

    function histogramequalization(img,filename)
    % e.g.
    %   color=imread('color.jpg');
    %   histogramequalization(color,'color');
    img=im2uint8(img);
    rows=length(img(:,1));
    cols=length(img(1,:))/length(img(1,1,:));
    iscolorful=false;
    if img(1,1,1)~=img(1,1,2)
        iscolorful=true;
        img=rgb2hsi(img);
    end
    % (1)$n_j$
    n_j=drawgrayscalehistogram(img,filename);
    % (2)$P_f\left(f_j\right)=\frac{n_j}{n}$
    p_f=n_j/(rows*cols);
    % (3)$C_\left(f\right)$
    c=p_f;
    for i=2:length(p_f)
        c(i)=c(i) + c(i-1);
    end
    % (4)$ \left \lfloor 255C\left(f\right)+0.5 \right \rfloor $
    g=round(255*c);
    % (5)$n_i$
    n_i=zeros(1,length(n_j));
    for i=1:length(n_j)
        temp=abs(g(i)+1);
        n_i(temp)=n_i(temp)+n_j(i);
    end
    % (6)$P_g\left(g_i\right)=\frac{n_i}{n}$
    p_g=n_i/(rows*cols);
    % (7)$f_i\rightarrow g_i$
    h=figure;
    ind=0:255;
    plot(ind, g, '-');
    title(['Mapping relation: $f_i {\rightarrow} g_i$'],'Interpreter','LaTeX');
    xlabel('$f_i$','Interpreter','LaTeX');
    ylabel('$g_i$','Interpreter','LaTeX');
    saveas(h,[filename, '_mapping_relation'],'png');
    close();
    % start histogram equalization
    for i=1:rows
        for j=1:cols
            for k=1:3
                img(i,j,k)=g(abs(img(i,j,k)+1));
            end
        end
    end
    drawgrayscalehistogram(img,[filename,'_equalization']);
    if iscolorful
        img=hsi2rgb(img);
    end
    imwrite(img,[filename,'_equalization.jpg']);
    csvwrite([filename,'_equalization.csv'],[ind;n_j;c;g;n_i;p_g]);
    

    2.1.5 直方图规定化

    function histogrammatching(img,filename,refimg,refimgfilename)
    % e.g.
    %   img=imread('color.jpg');
    %   filename='color';
    %   refimg=imread('grey_equalization.jpg');
    %   refimgfilename='grey_equalization';
    %   histogrammatching(img,filename,refimg,refimgfilename);
    img=im2uint8(img);
    rows=length(img(:,1));
    cols=length(img(1,:))/length(img(1,1,:));
    iscolorful=false;
    if img(1,1,1)~=img(1,1,2)
        iscolorful=true;
        img=rgb2hsi(img);
    end
    % (1)$n_j$
    n_j=drawgrayscalehistogram(img,filename);
    % (2)$P_f\left(f_j\right)=\frac{n_j}{n}$
    p_f=n_j/(rows*cols);
    % (3)$C_\left(f\right)$
    c=p_f;
    for i=2:length(p_f)
        c(i)=c(i) + c(i-1);
    end
    % (4)$ \left \lfloor 255C\left(f\right)+0.5 \right \rfloor $
    g=round(255*c);
     
    % rules
    z_i=drawgrayscalehistogram(refimg,refimgfilename);
    [rowss,colss,ss]=size(refimg);
    p_z=z_i/(rowss*colss);
    % (5)$ C\left(z\right)=\sum_{i=0}^{k} P_z\left(Z_i\right) $
    c_z=p_z;
    for i=2:length(p_z)
        c_z(i)=c_z(i)+c_z(i-1);
    end
    % (6)$ \left \lfloor 255C\left(f\right)+0.5 \right \rfloor $
    y_n=round(255*c_z); 
    % (7)$f_i \rightarrow Z_i$
    mapping=zeros(1,256);
    for i=1:length(g)
        gs=abs(g(i));
        % find a grayscale in y_n which is closest to gs
        [temp,mapping(i)]=findclosest(gs, y_n);
    end
     
    h=figure;
    ind=0:255;
    plot(ind, mapping, '-');
    title(['Mapping relation (refers to ', refimgfilename, '): $f_i {\rightarrow} g_i$'],'Interpreter','LaTeX');
    xlabel('$f_i$','Interpreter','LaTeX');
    ylabel('$g_i$','Interpreter','LaTeX');
    saveas(h,[filename,'_refer_',refimgfilename,'_mapping_relation'],'png');
    close();
     
    % (8) P_z\left(Z_i\right)
    z_i_=zeros(1,length(z_i));
    for i=1:length(z_i)
        temp=abs(mapping(i)+1);
        z_i_(temp)=z_i_(temp)+z_i(i);
    end
    p_z_z_i=z_i_/(rows*cols);
     
    % start histogram matching
    for i=1:rows
        for j=1:cols
            for k=1:3
                img(i,j,k)=mapping(abs(img(i,j,k)+1));
            end
        end
    end
    if iscolorful
        img=hsi2rgb(img);
    end
    imwrite(img,[filename,'_matching.jpg']);
    drawgrayscalehistogram(img,[filename,'_matching']);
    csvwrite([filename,'_matching.csv'],[ind;n_j;c;g;z_i;p_z;c_z;y_n;p_z_z_i]);
    

    2.1.6 调用脚本

    function main()
    addpath('./functions');
    format long;
    color=imread('color.jpg');
    histogramequalization(color,'color');
    grey=imread('grey.png');
    histogramequalization(grey,'grey');
     
    grey_equalization=imread('grey_equalization.jpg');
    histogrammatching(color,'color',grey,'grey');
    histogrammatching(color,'color',grey_equalization,'grey_equalization');
    

    2.2 Python实现

    2.2.0 引入(import)

    import csv
    import matplotlib.pyplot as plt
    import matplotlib.image as mping
    import numpy as np
    from numpy import cos, arccos, sqrt, power, pi
    

    2.2.1 RGB转HSI

    # FUNCTION  RGB转HSI
    # INPUT     RGB图像数据
    # OUTPUT    uint8格式HSI图像数据
    def rgb2hsi(rgb):
        # 如果没有归一化处理,则需要进行归一化处理(传入的是[0,255]范围值)
        if rgb.dtype.type == np.uint8:
            rgb = rgb.astype('float64')/255.0
        for i in range(rgb.shape[0]):
            for j in range(rgb.shape[1]):
                r, g, b = rgb[i, j, 0], rgb[i, j, 1], rgb[i, j, 2]
                # 计算h
                num = 0.5 * ((r-g)+(r-b))
                den = sqrt(power(r-g, 2)+(r-b)*(g-b))
                theta = arccos(num/den) if den != 0 else 0
                rgb[i, j, 0] = theta if b <= g else (2*pi-theta)
                # 计算s
                rgb[i, j, 1] = (1 - 3 * min([r, g, b]) / (r+g+b)) if r+g+b != 0 else 0
                # 计算i
                rgb[i, j, 2] = 1 / 3 * (r+g+b)
        return (rgb * 255).astype('uint8')
        ```
    ### 2.2.2 HSI转RGB
    ```python
    # FUNCTION  HSI转RGB
    # INPUT     HSI图像数据
    # OUTPUT    uint8格式RGB图像数据
    def hsi2rgb(hsi):
        if hsi.dtype.type == np.uint8:
            hsi = (hsi).astype('float64') / 255.0
        for k in range(hsi.shape[0]):
            for j in range(hsi.shape[1]):
                h, s, i = hsi[k, j, 0], hsi[k, j, 1], hsi[k, j, 2]
                r, g, b = 0, 0, 0
                if 0 <= h < 2/3*pi:
                    b = i * (1 - s)
                    r = i * (1 + s * cos(h) / cos(pi/3-h))
                    g = 3 * i - (b + r)
                elif 2/3*pi <= h < 4/3*pi:
                    r = i * (1 - s)
                    g = i * (1 + s * cos(h-2/3*pi) / cos(pi - h))
                    b = 3 * i - (r + g)
                elif 4/3*pi <= h <= 5/3*pi:
                    g = i * (1 - s)
                    b = i * (1 + s * cos(h - 4/3*pi) / cos(5/3*pi - h))
                    r = 3 * i - (g + b)
                hsi[k, j, 0], hsi[k, j, 1], hsi[k, j, 2] = r, g, b
        return (hsi * 255).astype('uint8')
    

    2.2.3 绘制灰度直方图

    # FUNCTION  绘制灰度直方图
    # INPUT     图像数据、灰度直方图保存文件名
    # OUTPUT    (灰度级,对应灰度级的频数)
    def draw_grayscale_histogram(img, filename=''):
        # 给定的两幅图像jpg是uint8,png是float32
        # 如果传入的是png图像,需要转化为[0,255]
        if img.dtype.type != np.uint8:
            img = (img*255).astype(np.uint8)
        # 由于彩色图像的直方图均衡化是在亮度通道上进行,故暂认为灰度直方图也绘制在亮度通道上进行统计绘制
        arr = np.array([0]*256)
        for i in range(img.shape[0]):
            for j in range(img.shape[1]):
                # H S I分别是0 1 2位置
                # 灰色PNG图像RGB三通道都一样,彩色图像转为HSI后取I通道
                arr[img[i, j, 2]] += 1
        ind = np.arange(256)
        plt.bar(ind, arr)
        filename = "_".join([filename, "grayscale", "histogram"])
        plt.title(filename)
        plt.savefig(filename+".png", dpi=72)
        plt.close()
        return ind, arr
    

    2.2.4 直方图均衡化

    # FUNCTION  直方图均衡化
    # INPUT     图像数据
    # OUTPUT    均衡化后的图像数据
    def histogram_equalization(img, filename=''):
        is_jpg = False
        is_png = False
        # 如果输入图像是.jpg格式,需要转HSI
        if img.dtype.type == np.uint8:
            is_jpg = True
            img = rgb2hsi(img)
        # 如果输入图像是.png格式,为方便处理需要转[0,255]
        elif img.dtype.type != np.uint8:
            is_png = True
            img = (img*255).astype(np.uint8)
        # (1)统计$n_j$
        ind, n_j = draw_grayscale_histogram(img, filename)
        # (2)计算$P_f\left(f_j\right)=\frac{n_j}{n}$
        p_f = n_j / (img.shape[0]*img.shape[1])
        # (3)计算$C_\left(f\right)$
        # c = [p_f[i-1]+p_f[i] for i in range(1, len(p_f))]
        c = p_f
        for i in range(1, len(p_f)):
            c[i] += c[i-1]
        # (4)求$ \left \lfloor 255C\left(f\right)+0.5 \right \rfloor $
        g = [int(255*ele+0.5) for ele in c]
        # (5)计算$n_i$
        n_i = np.array([0]*len(n_j))
        for i in range(len(n_j)):
            n_i[g[i]] += n_j[i]
        # (6)计算$P_g\left(g_i\right)=\frac{n_i}{n}$
        p_g = n_i / (img.shape[0]*img.shape[1])
        # (7)映射关系$f_i\rightarrow g_i$
        plt.plot(ind, g, '-')
        plt.title('''Mapping relation: $f_i \\rightarrow g_i$''')
        plt.xlabel('''$f_i$''')
        plt.ylabel('''$g_i$''')
        plt.savefig('_'.join([filename, "mapping", "relation"]))
        plt.close()
        # 绘制直方图均衡化后的灰度直方图
        # 如果输入图像是.png格式,均衡化之前需要转化到[0,255]
        for i in range(img.shape[0]):
            for j in range(img.shape[1]):
                for k in range(3):
                    img[i, j, k] = g[img[i, j, k]]
        # 如果输入图像是.png格式,均衡化转换之后需要转化回[0,1]
        if is_png:
            img = (img/255).astype(np.float32)
        # 如果输入图像是.jpg格式,均衡化转换之后需要转换回RGB
        elif is_jpg:
            img = hsi2rgb(img)
        # 如果输入是.png,则输出也是".png";如果输入是".jpg",则输出也是".jpg"
        plt.imsave('_'.join([filename, "equalization"])+(".png" if is_png else ".jpg"), img)
        # 绘制直方图均衡化后的
        draw_grayscale_histogram(img, '_'.join([filename, "equalization"]))
        with open('_'.join([filename, "equalization"])+".csv", 'w+') as f:
            f_csv = csv.writer(f)
            f_csv.writerow(ind)
            f_csv.writerow(n_j)
            f_csv.writerow(c)
            f_csv.writerow(g)
            f_csv.writerow(n_i)
            f_csv.writerow(p_g)
    

    2.2.5 调用脚本

    # FUNCTION  调用测试代码
    if __name__ == '__main__':
        png = mping.imread('./grey.png').copy()
        histogram_equalization(png, 'grey')
    
        jpg = mping.imread('./color.jpg').copy()
        histogram_equalization(jpg, 'color')
    
        # 测试RGB转HSI和HSI转RGB
        # jpg = mping.imread('./color.jpg').copy()
        # hsi = rgb2hsi(jpg)
        # plt.imsave('./color_hsi.jpg', hsi)
        # jpg_recover = hsi2rgb(hsi)
        # plt.imsave('./color_recover.jpg', jpg_recover)
    

    3 实验结果

    3.1 grey.png直方图均衡化处理结果

    在这里插入图片描述在这里插入图片描述
    左、右分别为直方图均衡化前后。下一、下二分别为其灰度直方图。
    在这里插入图片描述
    在这里插入图片描述
    下为直方图均衡化时所用的灰度级变换曲线图。
    在这里插入图片描述
    数值数据见实验文件生成的.csv文件。

    3.2 color.jpg直方图均衡化处理结果

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

    左、右分别为直方图均衡化前后。下一、下二分别为其(亮度通道)灰度直方图。
    在这里插入图片描述
    在这里插入图片描述

    下为直方图均衡化时(对亮度通道)所用的灰度级变换曲线图。
    在这里插入图片描述
    数值数据见实验文件生成的.csv文件。

    3.2 color.jpg直方图规定化处理结果

    在这里插入图片描述在这里插入图片描述
    上图左、右分别为直方图均衡化前后。下图左为规定直方图,右为直方图规定化结果。
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述在这里插入图片描述

    下图从上至下分别为原图、相对grey直方图规定化、相对grey直方图均衡化结果直方图规定化的灰度直方图。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    从上至下分别为相对grey直方图规定化、相对grey直方图均衡化结果直方图规定化的灰度级变换曲线图。
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 首先是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()

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

    展开全文
  • 直方图均衡化(Histogram equalization)与直方图规定化

    万次阅读 多人点赞 2017-12-17 17:07:26
    心血来潮,想写一写直方图均衡化。...1、为什么要做直方图均衡化与直方图规定化 在现实的拍摄过程中,比如说视频监控领域,由于其图像的灰度分布集中在较窄的范围内,这就导致了图像的细节不够清晰。为什...

    心血来潮,想写一写直方图均衡化。我先说说为什么要写直方图均衡化,因为之前接触到理论上的面试,看起来很简单的知识点,其实暗藏着很多的玄机(-_-)。本文尽量尝试着去推导。推导之前写一下基本的原理。

     

    关注公众号,获取更多信息

     

    1、为什么要做直方图均衡化与直方图规定化

    在现实的拍摄过程中,比如说视频监控领域,由于其图像的灰度分布集中在较窄的范围内,这就导致了图像的细节不够清晰。为什么不清晰呢,因为灰度分布较窄时,那么,在计算对比度的时候,对比度就很小,所以就不清晰。为了使得图像变得清晰,那么就需要使得灰度值的差别变大,为了使得灰度值的差别变大,就意味着灰度分布就变的较宽,使得灰度值分布变得均匀,在某个灰度级区间内,像素的个数分布大致相同,这样才能使得图像的对比度增强,细节变得清晰可见。

     

    2、直方图均衡化的原理

     

    直方图均衡化就是对图像进行非线性拉伸,使得变换后的图像直方图分布均匀。那么怎样才能使得新图像的直方图分布均匀呢?

    在介绍直方图均衡化的原理之前,先介绍随机变量的函数分布的数学知识。

     

    2.1、随机变量的函数分布

    2.2.1、连续随机变量的函数分布

    假设连续随机变量的X的概率密度为,求X的函数的概率密度函数
    通用的做法是:
    (1)先求分布函数
    (2)对上面公式两端求导就可以求得概率密度函数
    另外,如果是单调函数,则可以用公式法来求解。
    这里有一个定理:假设随机变量X的概率密度为,设函数g(x)处处可导,且有(或者),则有是连续型随机变量,其概率密度函数为
    式中,,h(y)是g(x)的反函数
     
    证明(只证明的情形):
     
    时,则g(X)在上是严格单调增加的,而且其反函数h(y)也是存在的,且反函数也是单调增加可导的。
     
    因为,的取值范围为
    则当时,
    则当时,
    时,
    对y求导,则
    为什么成立呢,因为相当于把Y=g(X)转换为X=h(Y).
    同理,当时,
     
     

    2.2.2、离散随机变量的函数分布

    设X是离散型随机变量,X的分布律为
    则Y=g(X)的分布律为
    上面表中,当某两个g(xi)相等时,就把概率合并,就是概率相加,然后重新绘制表格。

     

    2.2 直方图均衡化的推导

    直方图均衡化的目的是使得变换后的图像的直方图是均匀分布的,又因为概率密度是指变量落在某个区间的概率,而累积分布函数的导数就是概率密度函数。所以,当分布均匀时,就是使得概率密度能够保持为一个常数。有了这些分析,我们的目的就是想找到这样的一种变换函数,使得变换后图像直方图分布均匀(这里的直方图都用灰度级的个数除以总像素个数,进行归一化。)

    假设r和s分别是变换之前和变换之后的图像灰度级,r和s都进行了归一化的处理。假设变换函数为

    s=T(r),此变换公式满足0≤r≤1,0≤s≤1;当0≤r≤1时,T(r)是单调递增的。

    ,假设r的概率密度为P(r),则s的概率密度可以表示为(根据上面我们介绍的概率密度函数的求解方法):

    (1)

    假设从r到s的变换函数为

      (2)

    式中,明显是r的累积分布函数(也就是

    公式(2)两边对r求导得到

    带入到公式(1)中,得到

    哇,太神奇了,当我们用r的累积分布函数作为变换函数时,得到s的概率密度函数是1(也就是均匀的意思)。

    好了,这里就用连续函数的方式证明了采用原始图像直方图的累积分布来实现直方图均衡化是可行的。

     

    由于我们的图像是离散的,所以,这样怎么求变换后的图像呢,只是把连续的函数离散化就行了。

    (1)先求原始图像的直方图,就是每个灰度级的像素个数除以总像素个数,就是概率密度,

    (2)原始图像灰度级概率密度的累积就是新图像灰度级的概率密度

    k是新图像的灰度级,最大是255,也可以任意设置。

    (3)由于上面求得的s是0到1之间的,然后乘以255或者设置的最大灰度级,就得到新图像的灰度值。

     

    好了,这里就基本上说明了为什么要采用累积分布做直方图均衡化,以及如何做直方图均衡化。

     

    3、直方图规定化

    前面介绍了直方图均衡化,但是这是一种通用的对比度提升方法,如果我们想把图像变换到制定的直方图就显得力不从心。所以就有了直方图规定化,就是对原始图像做变换,使得变换后的图像的直方图跟我们规定的一样。

    假设原始图像的像素值为r,概率密度为P(r);做直方图均衡化之后的灰度值为s,均衡化之后的概率密度为P(s);希望要的图像的概率密度为P(z),再次情况下,求得其像素值z。

    实际上,规定化也是均衡化的一种,那么,就可以把均衡化的结果作为一种中间结果,建立起原始图像与固定化图像的一种桥梁。

    具体步骤如下:

    (1)首先对原始图像做直方图均衡化,得到每个像素s和累积分布T(s);

    (2)根据需要的规定化直方图,求累积分布G(Z);

    (3)显然,如果累积直方图中有0值,那么是不会分配像素值的,因为0乘以255还是零。

    (4)对于每一个T(s)(假设其像素值为ss),找到在G(Z)中与其差值最小的那个G(z)值(假设对应的像素值为zz),那么规定化后就把ss变换为zz。

     

    下面用两个典型的例子来说明,(数据来源于互联网,如有侵权,请告知)

     

     

     

     

    展开全文
  • 图像处理基础(8):图像的灰度直方图、直方图均衡化、直方图规定化(匹配) ... 本文主要介绍了灰度直方图相关的处理,包括以下几个方面的内容: ...利用OpenCV计算图像的灰度...直方图规定化(匹配)的原理及实现 ...

    图像处理基础(8):图像的灰度直方图、直方图均衡化、直方图规定化(匹配)

     https://www.cnblogs.com/wangguchangqing/p/7098213.html

    本文主要介绍了灰度直方图相关的处理,包括以下几个方面的内容:

    • 利用OpenCV计算图像的灰度直方图,并绘制直方图曲线
    • 直方图均衡化的原理及实现
    • 直方图规定化(匹配)的原理及实现

    图像的灰度直方图

    一幅图像由不同灰度值的像素组成,图像中灰度的分布情况是该图像的一个重要特征。图像的灰度直方图就描述了图像中灰度分布情况,能够很直观的展示出图像中各个灰度级所占的多少。
    图像的灰度直方图是灰度级的函数,描述的是图像中具有该灰度级的像素的个数:其中,横坐标是灰度级,纵坐标是该灰度级出现的频率。

    不过通常会将纵坐标归一化到[0,1][0,1]区间内,也就是将灰度级出现的频率(像素个数)除以图像中像素的总数。灰度直方图的计算公式如下:

    p(rk)=nkMNp(rk)=nkMN

    其中,rkrk是像素的灰度级,nknk是具有灰度rkrk的像素的个数,MNMN是图像中总的像素个数。

     

    OpenCV灰度直方图的计算

    直方图的计算是很简单的,无非是遍历图像的像素,统计每个灰度级的个数。在OpenCV中封装了直方图的计算函数calcHist,为了更为通用该函数的参数有些复杂,其声明如下:

    void calcHist( const Mat* images, int nimages,
                              const int* channels, InputArray mask,
                              OutputArray hist, int dims, const int* histSize,
                              const float** ranges, bool uniform = true, bool accumulate = false );

    该函数能够同时计算多个图像,多个通道,不同灰度范围的灰度直方图.
    其参数如下:

    • images,输入图像的数组,这些图像要有相同大大小,相同的深度(CV_8U CV_16U CV_32F).
    • nimages ,输入图像的个数
    • channels,要计算直方图的通道个数。
    • mask,可选的掩码,不使用时可设为空。要和输入图像具有相同的大小,在进行直方图计算的时候,只会统计该掩码不为0的对应像素
    • hist,输出的直方图
    • dims,直方图的维度
    • histSize,直方图每个维度的大小
    • ranges,直方图每个维度要统计的灰度级的范围
    • uniform,是否进行归一化,默认为true
    • accumulate,累积标志,默认值为false。

    为了计算的灵活性和通用性,OpenCV的灰度直方图提供了较多的参数,但对于只是简单的计算一幅灰度图的直方图的话,又显得较为累赘。这里对calcHist进行一次封装,能够方便的得到一幅灰度图直方图。

    class Histogram1D
    {
    private:
        int histSize[1]; // 项的数量
        float hranges[2]; // 统计像素的最大值和最小值
        const float* ranges[1];
        int channels[1]; // 仅计算一个通道
    
    public:
        Histogram1D()
        {
            // 准备1D直方图的参数
            histSize[0] = 256;
            hranges[0] = 0.0f;
            hranges[1] = 255.0f;
            ranges[0] = hranges;
            channels[0] = 0;
        }
    
        MatND getHistogram(const Mat &image)
        {
            MatND hist;
            // 计算直方图
            calcHist(&image ,// 要计算图像的
                1,                // 只计算一幅图像的直方图
                channels,        // 通道数量
                Mat(),            // 不使用掩码
                hist,            // 存放直方图
                1,                // 1D直方图
                histSize,        // 统计的灰度的个数
                ranges);        // 灰度值的范围
            return hist;
        }
    
        Mat getHistogramImage(const Mat &image)
        {
            MatND hist = getHistogram(image);
    
            // 最大值,最小值
            double maxVal = 0.0f;
            double minVal = 0.0f;
    
            minMaxLoc(hist, &minVal, &maxVal);
    
            //显示直方图的图像
            Mat histImg(histSize[0], histSize[0], CV_8U, Scalar(255));
    
            // 设置最高点为nbins的90%
            int hpt = static_cast<int>(0.9 * histSize[0]);
            //每个条目绘制一条垂直线
            for (int h = 0; h < histSize[0]; h++)
            {
                float binVal = hist.at<float>(h);
                int intensity = static_cast<int>(binVal * hpt / maxVal);
                // 两点之间绘制一条直线
                line(histImg, Point(h, histSize[0]), Point(h, histSize[0] - intensity), Scalar::all(0));
            }
            return histImg;
        }
    };

    Histogram1D提供了两个方法:getHistogram返回统计直方图的数组,默认计算的灰度范围是[0,255];getHistogramImage将图像的直方图以线条的形式画出来,并返回包含直方图的图像。测试代码如下:

        Histogram1D hist;
        Mat histImg;
        histImg = hist.getHistogramImage(image);
    
        imshow("Image", image);
        imshow("Histogram", histImg);

    其结果如下:

    直方图均衡化 Histogram Equalization

    假如图像的灰度分布不均匀,其灰度分布集中在较窄的范围内,使图像的细节不够清晰,对比度较低。通常采用直方图均衡化直方图规定化两种变换,使图像的灰度范围拉开或使灰度均匀分布,从而增大反差,使图像细节清晰,以达到增强的目的。
    直方图均衡化,对图像进行非线性拉伸,重新分配图像的灰度值,使一定范围内图像的灰度值大致相等。这样,原来直方图中间的峰值部分对比度得到增强,而两侧的谷底部分对比度降低,输出图像的直方图是一个较为平坦的直方图。

    均衡化算法

    直方图的均衡化实际也是一种灰度的变换过程,将当前的灰度分布通过一个变换函数,变换为范围更宽、灰度分布更均匀的图像。也就是将原图像的直方图修改为在整个灰度区间内大致均匀分布,因此扩大了图像的动态范围,增强图像的对比度。通常均衡化选择的变换函数是灰度的累积概率,直方图均衡化算法的步骤:

    • 计算原图像的灰度直方图 P(Sk)=nknP(Sk)=nkn,其中nn为像素总数,nknk为灰度级SkSk的像素个数
    • 计算原始图像的累积直方图 CDF(Sk)=i=0knin=i=0kPs(Si)CDF(Sk)=∑i=0knin=∑i=0kPs(Si)
    • Dj=LCDF(Si)Dj=L⋅CDF(Si),其中 DjDj是目的图像的像素,CDF(Si)CDF(Si)是源图像灰度为i的累积分布,L是图像中最大灰度级(灰度图为255)

    其代码实现如下:

    • 在上面中封装了求灰度直方图的类,这里直接应用该方法得到图像的灰度直方图;
    • 将灰度直方图进行归一化,计算灰度的累积概率;
    • 创建灰度变化的查找表
    • 应用查找表,将原图像变换为灰度均衡的图像

    具体代码如下:

    void equalization_self(const Mat &src, Mat &dst)
    {
        Histogram1D hist1D;
        MatND hist = hist1D.getHistogram(src);
    
        hist /= (src.rows * src.cols); // 对得到的灰度直方图进行归一化
        float cdf[256] = { 0 }; // 灰度的累积概率
        Mat lut(1, 256, CV_8U); // 灰度变换的查找表
        for (int i = 0; i < 256; i++)
        {
            // 计算灰度级的累积概率
            if (i == 0)
                cdf[i] = hist.at<float>(i);
            else
                cdf[i] = cdf[i - 1] + hist.at<float>(i);
    
            lut.at<uchar>(i) = static_cast<uchar>(255 * cdf[i]); // 创建灰度的查找表
        }
    
        LUT(src, lut, dst); // 应用查找表,进行灰度变化,得到均衡化后的图像
    
    }

    上面代码只是加深下对均衡化算法流程的理解,实际在OpenCV中也提供了灰度均衡化的函数equalizeHist,该函数的使用很简单,只有两个参数:输入图像,输出图像。下图为,上述代码计算得到的均衡化结果和调用equalizeHist的结果对比

    最左边为原图像,中间为OpenCV封装函数的结果,右边为上面代码得到的结果。

    直方图规定化

    从上面可以看出,直方图的均衡化自动的确定了变换函数,可以很方便的得到变换后的图像,但是在有些应用中这种自动的增强并不是最好的方法。有时候,需要图像具有某一特定的直方图形状(也就是灰度分布),而不是均匀分布的直方图,这时候可以使用直方图规定化
    直方图规定化,也叫做直方图匹配,用于将图像变换为某一特定的灰度分布,也就是其目的的灰度直方图是已知的。这其实和均衡化很类似,均衡化后的灰度直方图也是已知的,是一个均匀分布的直方图;而规定化后的直方图可以随意的指定,也就是在执行规定化操作时,首先要知道变换后的灰度直方图,这样才能确定变换函数。规定化操作能够有目的的增强某个灰度区间,相比于,均衡化操作,规定化多了一个输入,但是其变换后的结果也更灵活。

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

    • 将原始图像的灰度直方图进行均衡化,得到一个变换函数s=T(r)s=T(r),其中s是均衡化后的像素,r是原始像素
    • 对规定的直方图进行均衡化,得到一个变换函数v=G(z)v=G(z),其中v是均衡化后的像素,z是规定化的像素
    • 上面都是对同一图像的均衡化,其结果应该是相等的,s=v,z=G1(v)=G1(T(r))s=v,且z=G−1(v)=G−1(T(r))

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

    详解规定化过程

    对图像进行直方图规定化操作,原始图像的直方图和以及规定化后的直方图是已知的。假设Pr(r)Pr(r)表示原始图像的灰度概率密度,Pz(z)Pz(z)表示规定化图像的灰度概率密度(r和z分别是原始图像的灰度级,规定化后图像的灰度级)。

    • 对原始图像进行均衡化操作,则有sk=T(rk)=Li=0i=kPr(rk)sk=T(rk)=L⋅∑i=0i=kPr(rk)
    • 对规定化的直方图进行均衡化操作,则vk=G(zm)=Lj=0j=mPz(zm)vk=G(zm)=L⋅∑j=0j=mPz(zm)
    • 由于是对同一图像的均衡化操作,所以有sk=vmsk=vm。
    • 规定化操作的目的就是找到原始图像的像素sksk到规定化后图像像素的zkzk之间的一个映射。有了上一步的等式后,可以得到sk=G(zk)sk=G(zk),因此要想找到sksk想对应的zkzk只需要在zz进行迭代,找到使式子G(zm)skG(zm)−sk的绝对值最小即可。
    • 上述描述只是理论的推导过程,在实际的计算过程中,不需要做两次的均衡化操作,具体的推导过程如下:
      sk=vkLi=0i=kPr(rk)=Lj=0j=mPz(zm)i=0i=kPr(rk)=j=0j=mPz(zm)sk=vkL⋅∑i=0i=kPr(rk)=L⋅∑j=0j=mPz(zm)∑i=0i=kPr(rk)=∑j=0j=mPz(zm)

      上面公式表示,假如sksk 规定化后的对应灰度是zmzm的话,需要满足的条件是sksk的累积概率和zmzm的累积概率是最接近的
      下面是一个具体计算的例子:

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

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

     

    直方图规定化的实现

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

    • 计算原图像的累积直方图
    • 计算规定直方图的累积直方图
    • 计算两累积直方图的差值的绝对值
    • 根据累积直方图差值建立灰度级的映射

    具体代码实现如下:

    void hist_specify(const Mat &src, const Mat &dst,Mat &result)
    {
        Histogram1D hist1D;
        MatND src_hist = hist1D.getHistogram(src);
        MatND dst_hist = hist1D.getHistogram(dst);
    
        float src_cdf[256] = { 0 };
        float dst_cdf[256] = { 0 };
    
        // 源图像和目标图像的大小不一样,要将得到的直方图进行归一化处理
        src_hist /= (src.rows * src.cols);
        dst_hist /= (dst.rows * dst.cols);
    
        // 计算原始直方图和规定直方图的累积概率
        for (int i = 0; i < 256; i++)
        {
            if (i == 0)
            {
                src_cdf[i] = src_hist.at<float>(i);
                dst_cdf[i] = dst_hist.at<float>(i);
            }
            else
            {
                src_cdf[i] = src_cdf[i - 1] + src_hist.at<float>(i);
                dst_cdf[i] = dst_cdf[i - 1] + dst_hist.at<float>(i);
            }
        }
    
        // 累积概率的差值
        float diff_cdf[256][256];
        for (int i = 0; i < 256; i++)
            for (int j = 0; j < 256; j++)
                diff_cdf[i][j] = fabs(src_cdf[i] - dst_cdf[j]);
    
        // 构建灰度级映射表
        Mat lut(1, 256, CV_8U);
        for (int i = 0; i < 256; i++)
        {
            // 查找源灰度级为i的映射灰度
            // 和i的累积概率差值最小的规定化灰度
            float min = diff_cdf[i][0];
            int index = 0;
            for (int j = 1; j < 256; j++)
            {
                if (min > diff_cdf[i][j])
                {
                    min = diff_cdf[i][j];
                    index = j;
                }
            }
            lut.at<uchar>(i) = static_cast<uchar>(index);
        }
    
        // 应用查找表,做直方图规定化
        LUT(src, lut, result);
    }

    上面函数的第二个参数的直方图就是规定化的直方图。代码比较简单,这里就不一一解释了。其结果如下:

    左边是原图像,右边是规定化的图像,也就是上面函数的第一个和第二个输入参数。原图像规定化的结果如下:

    原图像规定化后的直方图和规定化的图像的直方图的形状比较类似, 并且原图像规定化后整幅图像的特征和规定化的图像也比较类似,例如:原图像床上的被子,明显带有规定化图像中水的波纹特征。

    直方图规定化过程中,在做灰度映射的时候,有两种常用的方法:

    • 单映射 Single Mapping Law,SML,这种方法也是上面使用的方法,根据累积直方图的差值,从原图像中找到其在规定化图像中的映射。
    • 组映射 Group Mapping Law,GML 这种方法较上述方法复杂不少,但是处理效果较好。

    对于GML的映射方法,一直没有很好的理解,但是根据其算法描述实现了该方法,代码这里先不放出,其处理结果如下:

    其结果较SML来说更为亮一些,床上的波浪特征也更为明显,但是其直方图形状,和规定化的直方图对比,第一个峰不是很明显。

    总结

    • 图像的灰度直方图能够很直观的展示图像中灰度级的整体分布情况,对图像的后续处理有很好的指导作用。
    • 直方图的均衡化的是将一幅图像的直方图变平,使各个灰度级的趋于均匀分布,这样能够很好的增强图像对比度。直方图均衡化是一种自动化的变换,仅需要输入图像,就能够确定图像的变换函数。但是直方图的均衡化操作也有一定的确定,在均衡化的过程中对图像中的数据不加选择,这样有可能会增强图像的背景;变换后图像的灰度级减少,有可能造成某些细节的消失;会压缩图像直方图中的高峰,造成处理后图像对比度的不自然等。
    • 直方图规定化,也称为直方图匹配,经过规定化处理将原图像的直方图变换为特定形状的直方图(上面中的示例,就是将图像的直方图变换为另一幅图像的直方图)。它可以按照预先设定的某个形状来调整图像的直方图,运用均衡化原理的基础上,通过建立原始图像和期望图像之间的关系,选择地控制直方图,使原始图像的直方图变成规定的形状它可以按照预先设定的某个形状来调整图像的直方图。直方图规定化是在运用均衡化原理的基础上,通过建立原始图像和期望图像之间的关系,选择地控制直方图,使原始图像的直方图变成规定的形状,从而弥补直方图均衡化的一些缺点.

    转载于:https://www.cnblogs.com/yumoye/p/10363361.html

    展开全文
  • 直方图规定化 原理: 所谓直方图规定化,就是通过一个灰度映像函数,将原灰度直方图改造成所希望的直方图。说的通俗一点就是,原图像的灰度是从0~255的,其分布是随机的,在一些情况下,我们可能需要一些特定的灰度...
  • 本文主要介绍了灰度直方图相关的处理,包括以下几个方面的内容:利用OpenCV计算图像的灰度直方图,并绘制直方图曲线直方图均衡化的原理及实现直方图规定化(匹配)的原理及实现图像的灰度直方图一幅图像由不同灰度值的...
  • 直方图规定化

    万次阅读 2013-11-24 20:20:04
    直方图规定化  原理:  在实际应用中,希望能够有目的地增强某个灰度区间的图像, 即能够人为地修正直方图的形状, 使之与期望的形状相匹配,这就是直方...直方图规定化是在运用均衡化原理的基础上,通过建立原始图
  • 本节为opencv数字图像处理(2):灰度变换与空间滤波的第二小节,直方图处理,主要包括:直方图均衡化与直方图规定化原理、推导与C++代码实现。
  • 直方图均衡化原理及计算

    千次阅读 多人点赞 2019-11-24 21:45:10
    直方图均衡化是基于灰度直方图的图像增强的一种方法,还有另外一种方法是直方图规定化。 均衡化的目的是将原始图像的直方图变为均衡分布的的形式,将一非均匀灰度概率密度分布图像,通过寻求某种灰度变换,变成一幅...
  • 直方图规定化计算过程

    万次阅读 多人点赞 2018-04-04 16:33:32
    书接上回,上一篇讲了直方图均衡化的原理,我们继续讲一下直方图规定化原理,在看这一篇之前请先看那一篇文章。 直方图均衡化计算过程: https://blog.csdn.net/macunshi/article/details/79815870 要想对图像...
  • 直方图规定化原理:所谓直方图规定化,就是通过一个灰度映像函数,将原灰度直方图改造成所希望的直方图。说的通俗一点就是,原图像的灰度是从0~255的,其分布是随机的,在一些情况下,我们可能需要一些特定的灰度值...
  • 今天先给出直方图均衡化和直方图规定化(匹配)。 1.直方图均衡化 针对整个图像偏较暗色调,对图像进行全局拉伸,增强图像质量 (1)代码 # include&amp;amp;amp;lt;iostream&amp;amp;amp;gt; # ...
  • 直方图规定化(匹配)的原理及实现 图像的灰度直方图 一幅图像由不同灰度值的像素组成,图像中灰度的分布情况是该图像的一个重要特征。图像的灰度直方图就描述了图像中灰度分布情况,能够很直观的展示出图像中各个...
  • 主要介绍直方图规定化的方法、原理、具体步骤等
  • 上一讲说明了直方图规定化的基本原理及步骤,这次来说说具体的例子。 直方图均衡化并不能适用于所有的情况,特别是,能够规定在进行处理后想要的图像直方图的形状,这在某些应用中是非常有用的。生成具有特定直方图...
  • 直方图规定化(匹配)

    千次阅读 2018-07-14 11:09:43
    直方图规定化定义:在运用均衡化原理基础上,通过建立原始图像和期望图像(待匹配直方图图像)之间的关系,使原始图像的直方图匹配特定的形状,从而弥补直方图均衡化不具备交互作用的特性。直方图规定化作用:1.可以...
  • OpenCV python 彩色图像的直方图规定化

    千次阅读 2018-12-17 21:38:50
    首先是opencv在图像处理方面...老师要求的是在hsv模型里对直方图进行规定化,所以如果你是在rgb模型下进行直方图规定化,只需要将rgb和hsv互相转化的部分删除即可,重点并不是这里。 import cv2 import numpy as n...
  • 直方图规定化c++实现

    千次阅读 2018-05-07 10:42:33
    直方图均衡化能够自动的扩展图像灰度的动态范围从而提高图像的对比度增强视觉效果...而直方图规定化是使图像具有指定的概率密度分布,在一些情况下能够获得更好的处理效果。简单叙述一下具体的步骤:(1)计算图像直...
  • 用灰度直方图增强图像对比度是基于图像灰度值统计的一种重要方法, 它以概率论为基础的, 常用的实现算法主要是直方图均衡化和直方图规定化。 直方图均衡化主要用于增强动态范围较小的图像的反差, 基...
  •  而灰度规定化可以弥补这个缺憾,能让我们通过灰度变换得到我们想要的灰度分布区间。在Matlab中没有直接实现灰度规定化的函数。但是我们可以通过imhist和histeq两个函数的结合使用来实现。示例程序如下:
  • 【图像处理】-006 直方图规定化

    千次阅读 2018-12-16 13:26:10
    直方图规定化 文章目录1 原理2 Matlab实现2.1 Matlab函数实现2.2 自己造轮子3 C++实现3.1 自己造轮子4 效果图 1 原理   直方图均衡可以使图像的灰度分布产生均分分布的特性,是一种较为方便的图像增强的方法。...
  • matlab实现直方图规定化

    万次阅读 多人点赞 2016-10-07 14:44:23
    对一幅灰度图像进行灰度变换,使变换后的图像的直方图与另外给定的一幅图像的直方图相匹配(近似相同)。 灰度图像:灰度图像在黑色与白色之间还有许多级的颜色深度。 原理及算法 原理参看下图,直方规范的理论...
  • 直方图匹配的原理就不多作解释了,我曾经还将MATLAB源码改写成过C源码,详情可见我的博文 根据MATLAB的histeq函数改写的运行在OpenCV下的直方图规定化C源码! 本文已转移到 ...
  • 本文在上一节学习直方图均衡化的基础上,介绍了对直方图进行处理的一种新方法:直方图规定化,系统地讲解了直方图规定化的定义、作用,应用及实现原理等,并采用C++语言和OpenCV编写算法代码,进行了演示。

空空如也

空空如也

1 2 3 4 5
收藏数 93
精华内容 37
关键字:

直方图规定化原理