精华内容
下载资源
问答
  • 对比度

    千次阅读 2018-08-24 20:06:02
    对比度高,画面看上去就很硬朗,对比度低,画面看上去就朦朦胧胧,比如下面这张图: 对比度和颜色没有关系,换句话说如果使用YUV颜色空间的话,那对比度只与Y通道值(亮度)有关。所以在这里,就...

    转载地址  http://blog.csdn.net/u012590570/article/details/50346325

    对比度和线性变换

    关于什么是对比度这事,不好用一个很明确很严谨的词来概括清楚。对比度高,画面看上去就很硬朗,对比度低,画面看上去就朦朦胧胧,比如下面这张图:

    这里写图片描述

    对比度和颜色没有关系,换句话说如果使用YUV颜色空间的话,那对比度只与Y通道值(亮度)有关。所以在这里,就先不提颜色了。

    针对8位灰度图来说,对比度高,就是白的很白(值接近0),黑的很黑(接近255)。

    于是乎,要提高对比度,只要把黑的变黑,白的变白就可以了。最简单的方法,把图上的每个像素的值都作一个线性变换。

    如果原图上像素值最大的点值为max(可能离255还很远),像素值最小的点的值为min(可能离0值也很远),线性变换就是要把值域(min,max)拉伸到(0,255)。所以很简单了:y=k(x-min),其中k权且叫做拉伸系数吧,k=255/(max-min)。

    把上面这张图,按照上文说的,做一下线性变换,于是得到了如下结果。

    这里写图片描述

    ok,对比度确实提高了。

    另外说一点儿,上文说道的max和min并不真的就是整张图上的最大值和最小值,实际上如果真的使用绝对的最大值和最小值的话,往往效果很差(值最大的那个点和值最小的那个点很有可能是坏点,或者是由噪声的影响)。一个方法是max取最大的5%的像素的值,min取最小的5%的像素的值(也未必一定是5%)。

    对上面这两张图做一下直方图统计,线性变换前的直方图如下:

    这里写图片描述

    线性变换后呢,直方图如下:

    这里写图片描述

    所以从直方图上看,线性变换不过就是把直方图移动了个位置,做了个拉伸而已。

     

    展开全文
  • 目的为解决局部带限对比度存在的问题,提出一种对比敏感度下的图像对比度评价方法.方法对低通滤波后的图像进行快速小波分解,然后对各级小波系数进行处理分别得到各级带通滤波图像及其相应低通滤波图像,求出Peli...
  • 计算图像对比度

    2018-10-28 22:16:11
    用MATLAB计算图像对比度的程序。包括4邻域和8邻域两种方法。还有计算对比度的算法文档。
  • 对比度matlab算法

    2019-02-18 09:49:09
    图像画质模糊,可以通过调节图像对比度来增强图像的画质
  • Use high contrast colors for maximum readability Recommended contrast ratio ...一个开源的颜色对比度分析工具。适合设计人员使用。 官方网站:https://developer.paciellogroup.com/resources/contrastanalyser/
  • 图像对比度

    2020-04-29 18:21:13
    一 图像对比度理论知识 1 定义 对比度:通俗地讲就是亮暗的拉伸对比程度,通常表现了图像画质的清晰程度。对比度的计算公式如下: 2 计算案例 解释: 每个小括号的数据是怎么来的?按四近邻计算,比如第一个小...

    一 图像对比度理论知识
    1 定义
    对比度:通俗地讲就是亮暗的拉伸对比程度,通常表现了图像画质的清晰程度。对比度的计算公式如下:

    å¨è¿éæå¥å¾çæè¿°
    2 计算案例

    å¨è¿éæå¥å¾çæè¿°

    解释:

    每个小括号的数据是怎么来的?按四近邻计算,比如第一个小括号:以第一行第一列为中心,上下左右分别与这个中心值相减再平方,然后加在一起,即:(2-1)2+(3-1)2;第二个小括号即:(1-3)2+(9-3)2+(1-3)2
    最后的48是怎么来的:其实就是总的平方次个数
    二 代码实现
    '''上面案例和下面代码都是使用四近邻方式计算'''
    from cv2 import cv2
    import numpy as np
    def contrast(img0):   
        img1 = cv2.cvtColor(img0, cv2.COLOR_BGR2GRAY) #彩色转为灰度图片
        m, n = img1.shape
        #图片矩阵向外扩展一个像素
        img1_ext = cv2.copyMakeBorder(img1,1,1,1,1,cv2.BORDER_REPLICATE) 
        rows_ext,cols_ext = img1_ext.shape
        b = 0.0
        for i in range(1,rows_ext-1):
            for j in range(1,cols_ext-1):
                b += ((img1_ext[i,j]-img1_ext[i,j+1])**2 + (img1_ext[i,j]-img1_ext[i,j-1])**2 + 
                        (img1_ext[i,j]-img1_ext[i+1,j])**2 + (img1_ext[i,j]-img1_ext[i-1,j])**2)

        cg = b/(4*(m-2)*(n-2)+3*(2*(m-2)+2*(n-2))+2*4) #对应上面48的计算公式
        print(cg)
       
    img0 = cv2.imread('1301022016GF2DOM_2535_5118_0_copy1.jpg')
    contrast(img0)
    img1 = cv2.imread('1301022016GF2DOM_2535_5118_0_copy2.jpg')
    contrast(img1)
    img2 = cv2.imread('1301022016GF2DOM_2535_5118_0_copy3.jpg')
    contrast(img2)
    img3 = cv2.imread('1301022016GF2DOM_2535_5118_0_copy4.jpg')
    contrast(img3)

    结果如下:
    20906.021314691152
    26861.281793266557
    27822.16401641625
    28115.63633277685
    结论:图片越清晰,对比度越大

    使用如下图片(因为下面图片大小被压缩,所以计算结果可能不一致,但大小顺序一致)
    ==

    å¨è¿éæå¥å¾çæè¿°

    å¨è¿éæå¥å¾çæè¿°

    å¨è¿éæå¥å¾çæè¿°

    å¨è¿éæå¥å¾çæè¿°

    展开全文
  • 图像处理 对比度拉伸

    2018-11-22 13:52:11
    数字图像处理 对比度拉伸
  • 这是基于区域的对比度的显著性检测代码,【关于原文请查看】 关于图像分割的区域对比度计算: 计算区域的中心与质心 区域颜色相似度距离的高斯权重分布 生成新区域 统计区域边界的像素数量 区域分割 #%%cython --c...


    这是基于区域的对比度的显著性检测代码,【关于原文请查看】
    关于图像分割的区域对比度计算:

    1. 计算区域的中心与质心。关于计算前的分割区域
    2. 区域颜色相似度距离的高斯权重分布
      在这里插入图片描述
    3. 生成新区域
    4. 统计区域边界的像素数量
    5. 形成分割区域

    开发环境win10,Visual studio 2015

    代码一
    #%%cython --cplus --annotate
    import numpy as np
    cimport cython
    cimport numpy as np
    from cpython cimport array
    from libc.math cimport pow
    from libc.math cimport sqrt
    from libc.math cimport exp
    from libc.math cimport fabs
    from libcpp.vector cimport vector
    from scipy.spatial.distance import pdist,squareform
    
    
    
    @cython.boundscheck(False)
    @cython.wraparound(False)
    cpdef Build_Regions_Contrast(int regNum, np.ndarray[np.int32_t, ndim=2] regIdx1i,
                                int[:,:] colorIdx1i, float[:,:,:]color3fv, float sigmaDist,float ratio,float thr):
        cdef:
            int height = regIdx1i.shape[0]
            int width = regIdx1i.shape[1]
            int colorNum = color3fv.shape[1]
            float cx = <float>width / 2.0
            float cy = <float>height / 2.0
            Py_ssize_t x = 0, y = 0, i=0, j=0, m=0, n=0, yi=0, xi=0,iii=0
    
        pixNum_np = np.zeros(regNum,dtype=np.int64)
        pixNum_np = np.bincount(regIdx1i.reshape(1, width * height)[0])
        
        ybNo_np = np.zeros(regNum, dtype=np.float64)
        regs_mX = np.zeros(regNum, dtype=np.float64)
        regs_mY = np.zeros(regNum, dtype=np.float64)
        regs_vX = np.zeros(regNum, dtype=np.float64)
        regs_vY = np.zeros(regNum, dtype=np.float64)
        
        freIdx_f64 = np.zeros((regNum, colorNum), dtype=np.float64)
        regColor_np = np.zeros((regNum, colorNum), dtype=np.int32)
        tile_pixNum = np.zeros((regNum, colorNum), dtype=np.int64)
        regs_np = np.zeros((regNum, 4), dtype=np.float64)
        
        cdef int [:,::1]regColor_view = regColor_np
        cdef double[:,::1]regs_view = regs_np
    
        with nogil:
            for y in range(height):
                for x in range(width):
                    regs_view[regIdx1i[y, x], 0] = fabs(x - cx)  # ad2c_0
                    regs_view[regIdx1i[y, x], 1] = fabs(y - cy)  # ad2c_1
                    regs_view[regIdx1i[y, x], 2] += x            # region center x coordinate
                    regs_view[regIdx1i[y, x], 3] += y            # region center y coordinate
                    regColor_view[regIdx1i[y, x], colorIdx1i[y, x]] += 1
    
        regs_np[:, 0] = np.divide(regs_np[:, 0], pixNum_np * width)
        regs_np[:, 1] = np.divide(regs_np[:, 1], pixNum_np * height)
        
        regs_mX = np.divide(regs_np[:, 2], pixNum_np)
        regs_mY = np.divide(regs_np[:, 3], pixNum_np)
        
        regs_np[:, 2] = np.divide(regs_mX, width)
        regs_np[:, 3] = np.divide(regs_mY, height)
    
    
        freIdx_f64 = regColor_np.astype(np.float64)
        tile_pixNum = np.tile(pixNum_np[:, np.newaxis], (1, colorNum))
        freIdx_f64 = np.divide(freIdx_f64, tile_pixNum)
    
        #==========================================================================================
    
        similar_dist = np.zeros((colorNum, colorNum), dtype=np.float64)
        similar_dist = squareform(pdist(color3fv[0]))
    
        rDist_np = np.zeros((regNum, regNum), np.float64)
        regSal1d_np = np.zeros((1, regNum), np.float64)
    
        
        cdef double[:,:]regs_view2 = regs_np
        cdef double[:]mX_view = regs_mX
        cdef double[:]mY_view = regs_mY
        cdef double[::1]vX_view = regs_vX
        cdef double[::1]vY_view = regs_vY
        
        cdef double[:,:]similar_dist_view = similar_dist
        cdef double[:,::1]rDist_view = rDist_np
        cdef double[:,::1]regSal1d_view = regSal1d_np
        cdef double[:,:]freIdx_f64_view = freIdx_f64
        cdef long long[:]pixNum_view = pixNum_np
        cdef double dd_np = 0.0
    
    
        with nogil:
            for i in range(regNum):
                for j in range(regNum):
                    if i < j:
                        for m in range(colorNum):
                            for n in range(colorNum):
                                if freIdx_f64_view[j, n] != 0.0 and freIdx_f64_view[i, m] != 0.0:
                                    dd_np += similar_dist_view[m,n] * freIdx_f64_view[i, m] * freIdx_f64_view[j, n]
                        rDist_view[i][j] = dd_np * exp(-1.0 * (pow((regs_view2[i, 2]-regs_view2[j, 2]),2)+pow((regs_view2[i, 3]-regs_view2[j, 3]),2)) / sigmaDist)
                        rDist_view[j][i] = rDist_view[i][j]
                        dd_np = 0.0
                    regSal1d_view[0, i] += pixNum_view[j] * rDist_view[i, j]
                regSal1d_view[0, i] *= exp(-9.0 * (pow(regs_view2[i, 0],2) + pow(regs_view2[i, 1],2)))
    
    
    
        #==========================================================================================
            for yi in range(height):
                for xi in range(width):
                    vX_view[regIdx1i[yi, xi]] += fabs(xi - mX_view[regIdx1i[yi, xi]])
                    vY_view[regIdx1i[yi, xi]] += fabs(yi - mY_view[regIdx1i[yi, xi]])
        regs_vX = np.divide(regs_vX,pixNum_np)
        regs_vY = np.divide(regs_vY,pixNum_np)
    
        
        #=======================在x和y边界区域的边界像素的数量================================
        cdef:
            vector[int] bPnts0
            vector[int] bPnts1
            array.array pnt = array.array('i',[0,0])
            int [:] pnt_view = pnt
            int wGap = <int>(width * ratio + 0.5)
            int hGap = <int>(height * ratio + 0.5)
            int sx = 0, sx_right = width - wGap
            double xR = 0.25* hGap
            double yR = 0.25* wGap
            double [::1] ybNum = ybNo_np
    
        with nogil:
            # top region
            while pnt_view[1] != hGap:
                pnt_view[0] = sx
                while pnt_view[0] != width:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
    
            pnt_view[0] = 0
            pnt_view[1] = height - hGap
            # Bottom region
            while pnt_view[1] != height:
                pnt_view[0] = sx
                while pnt_view[0] != width:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
            pnt_view[0] = 0
            pnt_view[1] = 0
            # Left Region
            while pnt_view[1] != height:
                pnt_view[0] = sx
                while pnt_view[0] != wGap:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
            pnt_view[0] = sx_right
            pnt_view[1] = 0
            # Right Region
            while pnt_view[1] != height:
                pnt_view[0] = sx_right
                while pnt_view[0] != width:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
    
        lk_np = np.zeros(regNum, np.float64)
        regL_np = np.zeros(regNum, np.int64)
        bReg1u = np.zeros((height, width), np.uint8)
        cdef unsigned char [:,::1]bReg1u_view = bReg1u
    
        lk_np = np.divide(np.multiply(ybNum,yR),regs_vX)
        regL_np = np.where(np.divide(lk_np,thr)>1,255,0)
        bReg1u = np.take(regL_np,regIdx1i)
    
    
        with nogil:
            for iii in range(bPnts0.size()):
                bReg1u_view[bPnts1[iii], bPnts0[iii]] = 255
        return regSal1d_np,bReg1u
    

    加速版,不知道为何,开启多线程加速,编译失败,代码如下:
    以下代码中的中去除了加速模块,若是需要请自行添加。

    代码二
    #%%cython --cplus --annotate
    import numpy as np
    cimport cython
    cimport numpy as np
    from cpython cimport array
    from libc.math cimport pow
    from libc.math cimport sqrt
    from libc.math cimport exp
    from libc.math cimport fabs
    from libcpp.vector cimport vector
    from scipy.spatial.distance import pdist,squareform
    
    
    
    @cython.cdivision(True)
    @cython.boundscheck(False)
    @cython.wraparound(False)
    cdef double[:,::1] init_regs(int[:,:] regIdx1i,
                                 double[:,::1]regs_view,
                                 int height,
                                 int width,
                                 float cx,
                                 float cy):
        cdef Py_ssize_t x = 0, y = 0
        with nogil:
            for y in range(height):
                for x in range(width):
                    regs_view[regIdx1i[y, x], 0] = fabs(x - cx)  # ad2c_0
                    regs_view[regIdx1i[y, x], 1] = fabs(y - cy)  # ad2c_1
                    regs_view[regIdx1i[y, x], 2] += x            # region center x coordinate
                    regs_view[regIdx1i[y, x], 3] += y            # region center y coordinate
            return regs_view
    
    
    @cython.cdivision(True)
    @cython.boundscheck(False)
    @cython.wraparound(False)
    cpdef Build_Regions_Contrast(int regNum, np.ndarray[np.int32_t, ndim=2] regIdx1i,
                                int[:,:] colorIdx1i, float[:,:,:]color3fv, float sigmaDist,float ratio,float thr):
        cdef:
            int height = regIdx1i.shape[0]
            int width = regIdx1i.shape[1]
            int colorNum = color3fv.shape[1]
            float cx = <float>width / 2.0
            float cy = <float>height / 2.0
            Py_ssize_t i=0, j=0, m=0, n=0, yi=0, xi=0,iii=0
    
        pixNum_np = np.zeros(regNum,dtype=np.int64)
        pixNum_np = np.bincount(regIdx1i.reshape(1, width * height)[0])
        
        ybNo_np = np.zeros(regNum, dtype=np.float64)
        regs_mX = np.zeros(regNum, dtype=np.float64)
        regs_mY = np.zeros(regNum, dtype=np.float64)
        regs_vX = np.zeros(regNum, dtype=np.float64)
        regs_vY = np.zeros(regNum, dtype=np.float64)
        
        freIdx_f64 = np.zeros((regNum, colorNum), dtype=np.float64)
        regColor_np = np.zeros((regNum, colorNum), dtype=np.int32)
        tile_pixNum = np.zeros((regNum, colorNum), dtype=np.int64)
        regs_np = np.zeros((regNum, 4), dtype=np.float64)
        np.add.at(regColor_np,[regIdx1i,colorIdx1i],1)
    
        cdef double[:,::1]regs_view = regs_np
        regs_view = init_regs(regIdx1i,regs_view,height,width,cx,cy)
    
    
        regs_np[:, 0] = np.divide(regs_np[:, 0], pixNum_np * width)
        regs_np[:, 1] = np.divide(regs_np[:, 1], pixNum_np * height)
        
        regs_mX = np.divide(regs_np[:, 2], pixNum_np)
        regs_mY = np.divide(regs_np[:, 3], pixNum_np)
        
        regs_np[:, 2] = np.divide(regs_mX, width)
        regs_np[:, 3] = np.divide(regs_mY, height)
    
    
        freIdx_f64 = regColor_np.astype(np.float64)
        tile_pixNum = np.tile(pixNum_np[:, np.newaxis], (1, colorNum))
        freIdx_f64 = np.divide(freIdx_f64, tile_pixNum)
    
        #==========================================================================================
    
        similar_dist = np.zeros((colorNum, colorNum), dtype=np.float64)
        similar_dist = squareform(pdist(color3fv[0]))
    
        rDist_np = np.zeros((regNum, regNum), np.float64)
        regSal1d_np = np.zeros((1, regNum), np.float64)
    
    
        cdef double[:]mX_view = regs_mX
        cdef double[:]mY_view = regs_mY
        cdef double[::1]vX_view = regs_vX
        cdef double[::1]vY_view = regs_vY
        
        cdef double[:,:]similar_dist_view = similar_dist
        cdef double[:,::1]rDist_view = rDist_np
        cdef double[:,::1]regSal1d_view = regSal1d_np
        cdef double[:,:]freIdx_f64_view = freIdx_f64
        cdef long long[:]pixNum_view = pixNum_np
        cdef double dd_np = 0.0
    
    
        with nogil:
            for i in range(regNum):
                for j in range(regNum):
                    if i < j:
                        for m in range(colorNum):
                            for n in range(colorNum):
                                if freIdx_f64_view[j, n] != 0.0 and freIdx_f64_view[i, m] != 0.0:
                                    dd_np += similar_dist_view[m,n] * freIdx_f64_view[i, m] * freIdx_f64_view[j, n]
                        rDist_view[i][j] = dd_np * exp(-1.0 * (pow((regs_view[i, 2]-regs_view[j, 2]),2)+pow((regs_view[i, 3]-regs_view[j, 3]),2)) / sigmaDist)
                        rDist_view[j][i] = rDist_view[i][j]
                        dd_np = 0.0
                    regSal1d_view[0, i] += pixNum_view[j] * rDist_view[i, j]
                regSal1d_view[0, i] *= exp(-9.0 * (pow(regs_view[i, 0],2) + pow(regs_view[i, 1],2)))
    
        #==========================================================================================
            for yi in range(height):
                for xi in range(width):
                    vX_view[regIdx1i[yi, xi]] += fabs(xi - mX_view[regIdx1i[yi, xi]])
                    vY_view[regIdx1i[yi, xi]] += fabs(yi - mY_view[regIdx1i[yi, xi]])
        regs_vX = np.divide(regs_vX,pixNum_np)
        regs_vY = np.divide(regs_vY,pixNum_np)
    
        
        #==================在x和y边界区域的边界像素的数量==========================
        cdef:
            vector[int] bPnts0
            vector[int] bPnts1
            array.array pnt = array.array('i',[0,0])
            int [:] pnt_view = pnt
            int wGap = <int>(width * ratio + 0.5)
            int hGap = <int>(height * ratio + 0.5)
            int sx = 0, sx_right = width - wGap
            double xR = 0.25* hGap
            double yR = 0.25* wGap
            double [::1] ybNum = ybNo_np
    
        with nogil:
            # top region
            while pnt_view[1] != hGap:
                pnt_view[0] = sx
                while pnt_view[0] != width:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
    
            pnt_view[0] = 0
            pnt_view[1] = height - hGap
            # Bottom region
            while pnt_view[1] != height:
                pnt_view[0] = sx
                while pnt_view[0] != width:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
            pnt_view[0] = 0
            pnt_view[1] = 0
            # Left Region
            while pnt_view[1] != height:
                pnt_view[0] = sx
                while pnt_view[0] != wGap:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
            pnt_view[0] = sx_right
            pnt_view[1] = 0
            # Right Region
            while pnt_view[1] != height:
                pnt_view[0] = sx_right
                while pnt_view[0] != width:
                    ybNum[regIdx1i[pnt_view[1], pnt_view[0]]] += 1
                    bPnts0.push_back(pnt_view[0])
                    bPnts1.push_back(pnt_view[1])
                    pnt_view[0] += 1
                pnt_view[1] += 1
    
    
        lk_np = np.zeros(regNum, np.float64)
        regL_np = np.zeros(regNum, np.int64)
        bReg1u = np.zeros((height, width), np.uint8)
        cdef unsigned char [:,::1]bReg1u_view = bReg1u
    
        lk_np = np.divide(np.multiply(ybNum,yR),regs_vX)
        regL_np = np.where(np.divide(lk_np,thr)>1,255,0)
        bReg1u = np.take(regL_np,regIdx1i)
    
        with nogil:
            for iii in range(bPnts0.size()):
                bReg1u_view[bPnts1[iii], bPnts0[iii]] = 255
        return regSal1d_np,bReg1u
    

    编译发出警告:LINK : warning LNK4044: 无法识别的选项“/openmp”;已忽略
    setup代码如下:

    from distutils.core import setup
    from distutils.extension import Extension
    from Cython.Distutils import build_ext
    import numpy as np
    
     
    filename = 'Regions_GetBorderReg_parallel'
    full_filename = 'Regions_GetBorderReg_parallel.pyx'
    
    
    ext_modules = [Extension(filename, [full_filename],
                            language='c++',
                            extra_compile_args=['-O3', '-march=native', '-ffast-math', '/openmp'],
                            extra_link_args=['/openmp'])]
    
    setup(
        cmdclass = {'build_ext': build_ext},
        ext_modules = ext_modules,
        include_dirs=[np.get_include()]
    )
    
    测试代码
    %%cython --cplus --annotate
    import numpy as np
    cimport cython
    cimport numpy as np
    from cpython cimport array
    from libc.math cimport pow
    from libc.math cimport sqrt
    from libc.math cimport exp
    from libc.math cimport fabs
    from libcpp.vector cimport vector
    cimport openmp
    from scipy.spatial.distance import pdist,squareform
    from cython.parallel import prange, parallel
    
    @cython.cdivision(True)
    @cython.boundscheck(False)
    @cython.wraparound(False)
    cdef double[:,::1] init_regs(int[:,:] regIdx1i,
                                 double[:,::1]regs_view,
                                 int x,
                                 int y,
                                 int height,
                                 int width,
                                 float cx,
                                 float cy):
        cdef int num_threads
        openmp.omp_set_dynamic(1)
        with nogil,parallel():
            num_threads = openmp.omp_get_num_threads()
            for y in range(height):
                for x in range(width):
                    regs_view[regIdx1i[y, x], 0] = fabs(x - cx)
                    regs_view[regIdx1i[y, x], 1] = fabs(y - cy)
                    regs_view[regIdx1i[y, x], 2] += x
                    regs_view[regIdx1i[y, x], 3] += y
    
            return regs_view
    
    %%cython --cplus --annotate
    import numpy as np
    cimport cython
    cimport numpy as np
    from cpython cimport array
    from libc.math cimport pow
    from libc.math cimport sqrt
    from libc.math cimport exp
    from libc.math cimport fabs
    from libcpp.vector cimport vector
    cimport openmp
    from scipy.spatial.distance import pdist,squareform
    from cython.parallel import prange, parallel
    
    @cython.cdivision(True)
    @cython.boundscheck(False)
    @cython.wraparound(False)
    cdef double[:,::1] init_regs(int[:,:] regIdx1i,
                                 double[:,::1]regs_view,
                                 int x,
                                 int y,
                                 int height,
                                 int width,
                                 float cx,
                                 float cy):
        with nogil,parallel(num_threads=4):
            for y in prange(height,schedule='dynamic'):
                for x in range(width):
                    regs_view[regIdx1i[y, x], 0] = fabs(x - cx)  # ad2c_0
                    regs_view[regIdx1i[y, x], 1] = fabs(y - cy)  # ad2c_1
                    regs_view[regIdx1i[y, x], 2] += x            # region center x coordinate
                    regs_view[regIdx1i[y, x], 3] += y            # region center y coordinate
            return regs_view
    
    

    参考
    https://stackoverflow.com/questions/40451203/cython-parallel-loop-problems
    https://cython.readthedocs.io/en/latest/src/userguide/parallelism.html

    展开全文
  • 对比度增强

    2018-04-03 22:45:01
    数字图像处理中对比度增强(对比度拉伸)的方法:(1)线性变换 y=a*x+b的方式,其中x表示原图,y表示输出图像。 a=1,b=0,y和x相同 a&gt;1对比度增强,a&lt;1对比度减弱 b&gt;0亮度增强,b&lt;0...

    数字图像处理中对比度增强(对比度拉伸)的方法:

    (1)线性变换

            y=a*x+b的方式,其中x表示原图,y表示输出图像。

            a=1,b=0,y和x相同

            a>1对比度增强,a<1对比度减弱

            b>0亮度增强,b<0亮度减弱

            除此之外,OpenCV中提供了函数convertTo()和convertScaleAbs()来实现

    (2)直方图正规化

            公式为:y=(y_max-y_min)/(x_max-x_min)*(x_(r,c)-x_min)+y_min;

            其中y表示输出图像的灰度级,灰度图多数是[0 255],x表示输入图像的灰度级

            说白了就是对灰度级进行了归一化的操作

            OpenCV函数为minMaxLoc()和normalize()

    (3)伽马变换

           公式为:y=x^n,n为伽马值,本质就是对原图进行幂运算

          OpenCV函数为pow()

    (4)全局直方图均衡化

        目的就是为了使得直方图更为均匀

    (5)自适应直方图均衡化

       是对4的改进

     



    展开全文
  • matlab对比度增强源代码,对比度增强是将图像中的亮度值范围拉伸或压缩成显示系统指定的亮度显示范围,从而提高图像全部或局部的对比度。输入图像中的每个亮度值通过一定的转换函数,对应于输出图像的一个显示值。
  • 主要介绍了C#图像对比度调整的方法,涉及C#实现图像对比度操作的相关技巧,需要的朋友可以参考下
  • 遥感图像直方图特点与实际意义,遥感图像对比度概念,对比度增强
  • 关于图像对比度【4】对比度调整强度之前说了两种调整对比度调整的方法,线性变换和直方图均衡化,之前写的时候都是把对比度增强的效果发挥到极致,但是很高的对比度真的好吗?有时候,我们是不需要这么强的对比度的...
  • 大多数显示行业的人士都认同,最终用户中很少有人能真正了解图像的亮度、色域广度及保真度对显示器的对比度有何种影响,然而以电视作主要消费品的液晶显示(LCD)消费制造商之间,在对比度方面的激烈竞争却丝毫没有...
  • 点运算又称为对比度增强、对比度拉伸或灰度变换,是一种通过图像中的每一个像素值进行运算的图像处理方式。。它将输入图像映射为输出图像,输出图像每个像素点的灰度值仅有对应的输入像素点的灰度值决定,运算结果...
  • VS2010 图像质量评价 对比度.sln
  • 图像增强主要解决由于图像的灰度级范围较小造成的对比度较低的问题,目的就是将输出图像的灰度级放大到指定的程度,使得图像中的细节看起来增加清晰。对比度增强有几种常用的方法,如线性变换、分段线性变换、伽马...
  • python opencv 对比度

    2019-09-05 15:36:59
    今天在做图像的目标区域提取时,发现总是有干扰导致不能正确的选取ROI区域,然后自己写了个增强对比度的方法,用自己的增强对比度的方法虽然可以成功处理,但是速度很慢,所以想要一个速度又快,效果又好的增强对比...
  • photoshop教程中增加对比度典型的应用就是处理一些发灰的照片,对比度不高,导致图像不清楚灰蒙蒙的感觉。  比如书法爱好者喜欢把自己的字画翻拍成照片保存,但翻拍的字幅,往往是“字不够黑”,“纸不够白”,...
  • 题目:定义一个图像的对比度拉伸函数,函数名为myGrayScaleTransform,将输入图像的对比度线性平滑地拉伸到指定的灰度级区间,要求该函数的输入参数包括处理前的灰度图像img1 (如EXP1A.tif)、期望灰度级的参数区间...
  • 在图像融合处理的过程中,常常为了比较同融合方法的优劣会选取对比度这个指标来评价融合的好坏,对比度即获取目标与背景的对比度
  • 关于图像对比度【1】对比度和线性变换关于什么是对比度这事,不好用一个很明确很严谨的词来概括清楚。对比度高,画面看上去就很硬朗,对比度低,画面看上去就朦朦胧胧,比如下面这张图:对比度和颜色没有关系,...
  • matlab开发-彩色图像对比度增强。这个程序演示了色彩空间中对比度增强的概念。
  • 关于图像对比度【5】——局部自适应对比度调整之前说的对比度都是对整幅图像来说的,在进行对比度调整的时候,也是对整幅图像使用了相同的参数,比如用线性变换的方法来做对比度调整,即y=kx+b,对于所有的像素点k和...
  • 清晰度、对比度和锐化程度的调整,是照片后期的三个重要步骤。它们容易混淆,但各自效果却并不相同。本文会帮大家从原理上理清他们的区别。  1  对比度  对比度是指的画面的明暗反差程度。增加对比度,画面中...
  • 亮度 对比度 饱和度 灰度

    千次阅读 2018-06-03 19:38:44
    亮度是指画面的明亮程度,单位是堪...更精准地说,对比度就是把白色信号在100%和0%的饱和度相减,再除以用Lux(光照度,即勒克斯,每平方米的流明值)为计量单位下0%的白色值(0%的白色信号实际上就是黑色),所得到的...
  • 容提要:文章详细介绍ps对比度的调整方法,并给出一幅缺乏对比度的问题图像来介绍。ps对比度调整包括使用ps自动对比度、色阶、曲线命令调整的原理和方法。  对比度是指一幅图像中,明暗区域中最亮的白色和最暗的...
  • 自适应对比度

    2018-09-06 14:23:18
    自适应对比度增强原理: ACE原理是将一幅图像分成两个部分:一是低频部分,可以通过图像的低通滤波(平滑模糊)获得;二是高频部分,可以由原图减去低频部分得到。而算法的目标是增强代表细节的高频部分,即对高频...
  • 利用matlab计算对比度

    2015-08-18 14:51:32
    一个计算对比度的matlab程序,考虑得到了边缘点的情况

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,167
精华内容 8,866
关键字:

对比度