精华内容
下载资源
问答
  • 伪彩色图像处理 刚萨雷斯数字图像处理 伪彩色图像(也称假彩色图像)图像处理包含根据特定标准对灰度值赋予颜色。 伪彩色图像用于区分对单色图像赋予彩色的处理和与真彩色图像相关的处理。因为人眼对彩色图像更为...

    伪彩色图像处理

    冈萨雷斯数字图像处理

    伪彩色图像(也称假彩色图像)图像处理包含根据特定标准对灰度值赋予颜色。
    伪彩色图像用于区分对单色图像赋予彩色的处理和与真彩色图像相关的处理。因为人眼对彩色图像更为敏感。(人眼可以辨别几千种色调和强度,相比之下却只能辨别20几种灰度。)可以说,伪彩色图像是对灰度图像灰度级的可视化和解释。

    1 灰度分层

    最简单的对于一张灰度图像,每一个像素点都对应一个灰度值。我们在灰度轴设置一个阈值,低于该阈值的像素点对应一种颜色,高于该阈值对应另一种颜色(理解为将图像二值化)。可以设置多个阈值,函数呈现阶梯式。
    在这里插入图片描述
    进一步,对于用于目标检测的灰度图像,我们只关注图像的某一物理特性时,将一种颜色赋给某一特定的灰度值,而将另一种颜色赋给所有其他灰度级。
    举例:1.甲状腺模型的灰度图像和伪彩色图像2.焊缝孔隙的灰度图像和伪图像。
    在这里插入图片描述

    2 灰度到彩色的变换

    彩色图像由三个通道(RGB),而灰度图像只有一个通道。
    对于灰度图像,可以将灰度值执行三个独立的变换,将变换的结果作为三个通道合成一张彩色图片。变换函数可以根据特定的情况进行调制。上一节的灰度分层身成为彩色图像使用的是分段线性函数。而这种变换是以平滑的非线性函数为基础的。
    在这里插入图片描述
    选择合适的变换函数可以对伪彩色图像进行进一步的彩色增强。
    在这里插入图片描述
    书中举例将三个颜色通道的变换函数分别设置成具有不同相位的正弦函数。因为不同物体的灰度值有差别,而变换函数的纵坐标分别对应三个颜色的强度。由于正弦函数呈周期性变化,所以选择特定的灰度级区段表示不同的物体,是不同的物体呈现出不同的颜色。
    1、在这里插入图片描述
    2、
    在这里插入图片描述
    图1中爆炸物和背景有不同的灰度级,能够很容易识别到爆炸物。而图2中爆炸物和背景在三个变换函数的映射相差很小,区分效果不好。

    3 灰度图像转换成伪彩色图像的算法(来自博客https://blog.csdn.net/jizhidexiaoming/article/details/80255383

    和第二部分的方法相似,将灰度图像通过三个变换函数(这里的变换函数就是分段的线性函数),转化成三个灰度值,作为彩色图像的三个通道。

    matlab程序:

    % 输入灰度级        输出彩色
    % 0~63  1/4         蓝色
    % 64~127 2/4        紫色
    % 128~191 3/4       黄色
    % 192~255  4/4      红色
    clc;
    clear;
    grayImage=rgb2gray(imread('D:\Code\Image\girl.jpg'));
    figure,imshow(grayImage);
    [row,col]=size(grayImage);
    range=255;%每个通道的最大灰度值
    
    R = zeros(row,col);
    G = zeros(row,col);
    B = zeros(row,col);
    for i=1:row
         for j=1:col
            if grayImage(i,j)<=range/4% [0,64]偏蓝
                R(i,j)=0;
                G(i,j)=4*grayImage(i,j);
                B(i,j)=range;
                else if grayImage(i,j)<=range/2% (64,128] 偏紫
                     R(i,j)=0;
                     G(i,j)=range;
                     B(i,j)=-4*grayImage(i,j)+2*range;
                    else if grayImage(i,j)<=3*range/4% (128, 192]
                            R(i,j)=4*grayImage(i,j)-2*range;
                            G(i,j)=range;
                            B(i,j)=0;
                         else
                            R(i,j)=range;
                            G(i,j)=4*(range-grayImage(i,j));
                            B(i,j)=0;
                        end
                    end
            end
        end
    end
    
    out = zeros(row,col);
    for i=1:row
        for j=1:col
                  out(i,j,1)=R(i,j);
                  out(i,j,2)=G(i,j);
                  out(i,j,3)=B(i,j);
        end
    end
    
    out=out/256;
    figure,imshow(out);
    

    python代码,还是用了opencv 待完善

    import cv2
    import numpy as np
    
    
    def to_gray(path):
        img = cv2.imread(path)
        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        return img_gray
    
    
    '''
    输入灰度级        输出彩色
     0~63  1/4         蓝色
     64~127 2/4        紫色
     128~191 3/4       黄色
     192~255  4/4      红色
    '''
    
    
    def show(img):
        cv2.imshow('img', img)
        cv2.waitKey()
        cv2.destroyAllWindows()
    
    
    def color(img_gray):
        row, col = img_gray.shape[:]
        print(row, col)
        b = np.zeros((row, col))
        print('b', b, b.shape[:])
        g = np.zeros((row, col))
        r = np.zeros((row, col))
        for i in range(row):
            for j in range(col):
                if(img_gray[i, j]<255//4):
                    b[i, j] = 255
                    g[i, j] = 4 * img_gray[i, j]
                    while (g[i, j]>255):
                        g[i, j] -= 255
                    r[i, j] = 0
                elif(img_gray[i, j]<255//2):
                    b[i, j] = -4 * img_gray[i, j]
                    while (b[i, j]<0):
                        b[i, j]+=255
                    g[i, j] = 255
                    r[i, j] = 0
                elif(img_gray[i, j]<3*255//4):
                    b[i, j] = 0
                    g[i, j] = 255
                    r[i, j] = 4*img_gray[i, j]-255*2
                    while (r[i, j]>255):
                        r[i, j]-=255
                else:
                    b[i, j] = 0
                    g[i, j] = -4*img_gray[i, j]+0*255
                    while (g[i, j]<0):
                        g[i, j] += 255
                    r[i, j] = 255
        img_color = cv2.merge([b, g, r])
        return img_color
    
    
    img_gray = to_gray('a.jpg')
    img_color = color(img_gray)
    show(img_gray)
    show(img_color)
    
    

    显示结果:
    在这里插入图片描述
    在这里插入图片描述

    感谢
    https://blog.csdn.net/weixin_41004352/article/details/90711499
    https://blog.csdn.net/jizhidexiaoming/article/details/80255383

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

    展开全文
  • 数字图像处理python实现-图像增强篇

    千次阅读 2020-02-08 17:33:54
    冈萨雷斯-图像增强篇内容简介直方图均衡增强空间域算子增强合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    直方图均衡增强

    直方图均衡是提高图像对比度达到图像增强的目的,即使得均衡后的图像像素值大体均匀分布在0-255之间 大体分3步

    1. 统计每个像素值所对应的个数
    2. 计算每个像素值所对应的累计概率
    3. 计算新的像素值
    def myEqualizeHist(I):
        rows, cols = I.shape
        array = np.zeros(256)
    
        # 统计像素个数
        for i in range(rows):
            for j in range(cols):
                array[I[i][j]] += 1
    
        # 算累计概率
        sum = 0
        for ary in range(0, len(array)):
            sum += array[ary] / (rows * cols)
            array[ary] = sum
    
        # 求均衡化后的像素值
        newI = np.zeros(I.shape)
        for i in range(rows):
            for j in range(cols):
                newI[i][j] = array[I[i][j]] * 255
    
        return newI
    

    与opencv 自带直方图均衡对比如下:
    在这里插入图片描述

    空间域算子增强

    在图像增强中除了直方图均衡以外大体的思路有大体两类

    1. g = f + k * s
      g 为增强后的图像
      f 为原图
      s 为锐化图像(如常见的拉普拉斯算子等一系列边缘提取的算子)
      k常数系数
    2. 使锐化算子中心处的权重增加,这样使得在平滑区域时为原像素值,在锐化区域内达到增大像素值的目的使得整体细节增强

    目前做增强或者只做锐化的常见做法差别,

    1. 拉普拉斯算子,缺点主要有在噪声处进行二阶差分使会使得噪声放大
      改进做法为LOG算子,

    2. LOG算子,高斯拉普拉斯算子,即在做拉普拉斯之前先进行高斯平滑去除噪声干扰,

    3. DOG算子 ,即差分高斯算子,即两个高斯算子差算子,等价做法为对高斯函数进行拉普拉斯再进行卷积,是对LOG算子的优化更符合人的视觉特性
      这里使用常见的拉普拉斯算子作为例子进行讲解

    代码如下

    def laplacianEnhance(f):
        rows, cols = f.shape
        f = np.array(f)
        newI = np.zeros(f.shape, dtype=np.float)
        mask = np.array([-2, 0, -2, 0, 8, 0, -2, 0, -2]).reshape(3, 3)
        for i in range(1, rows - 1):
            for j in range(1, cols - 1):
                newI[i][j] = np.sum(np.dot(f[i - 1:i + 2, j - 1:j + 2], mask))
    
        newI = newI.clip(0, 255)
        return newI
    

    与opencv自带拉普拉斯增强效果如下,这里的效果差别为使用的模版与opencv的默认模版不一致导致的
    在这里插入图片描述

    频率域增强

    频率域 g = f + s 其中s为高通图像(锐化图像)大体分为3步

    1. 得到图像的傅立叶谱(中心化后)
    2. 高通滤波处理
    3. 高通后得到的锐化图像与原图相加

    代码如下

    def enhance(f):
        rows, cols = f.shape
        f_mask = np.zeros(f.shape)
        original = np.zeros(f.shape)
    
        # 中心化预处理
        for i in range(f.shape[0]):
            for j in range(f.shape[1]):
                original[i, j] = f[i, j] * ((-1) ** (i + j))
    
        F = np.fft.fft2(original)
        # 生成高通滤波模板
        D0 = 20
        for i in range(rows):
            for j in range(cols):
                temp = (i - rows / 2) ** 2 + (j - cols / 2) ** 2
                f_mask[i, j] = 1 - np.e ** (-1 * temp / (2 * D0 ** 2))
    
        return np.abs(np.fft.ifft2(F * f_mask))
    
    def show(f, s, a, b, c):
        plt.subplot(a, b, c)
        plt.imshow(f, "gray")
        plt.axis('on')
        plt.title(s)
        
    def main():
    	f = enhance(original)
        plt.figure()
        show(original, "original", 2, 2, 1)
        show(f, "shape", 2, 2, 2)
        ret, dst = cv.threshold(f + original, 255, 255, cv.THRESH_TRUNC)
        show(dst, "enhance", 2, 2, 3)
        plt.show()
    

    效果如下:

    在这里插入图片描述
    以上3种类型的只是其中最为简单的容易理解的,针对其他的还有去噪声,光照问题等所使用的去噪算法,以及例如同态滤波,以及去雾等算法对图像的增强等在后面的文章将会涉及到

    最后谢谢读者的阅读,希望对您能有所帮助
    转载我博客应当经我允许,至少要把原文链接放在文章最前面,这是对本人辛苦原创基本的尊重。

    上一篇:数字图像处理学习路线大体介绍
    下一篇:数字图像处理冈萨雷斯-形态学处理

    展开全文
  • 判断图像是否为低对比度图像 通过指定低亮度像素在整个图像中...Python实现代码如下: def is_low_contrast(src,fraction_threshold=0.5, lower_percentile=1, upper_percentile=99): # 转换为灰度图像 src = np...

    判断图像是否为低对比度图像

    通过指定低亮度像素在整个图像中所占的比例来判断图像是否为低对比度图像。

    Python实现代码如下:

    def is_low_contrast(src,fraction_threshold=0.5, lower_percentile=1,
                        upper_percentile=99):
        # 转换为灰度图像
        src = np.asanyarray(src)
        if src.ndim == 3 and src.shape[2] in [3, 4]:
            src = cv2.cvtColor(src,cv2.COLOR_RGB2GRAY)
        # 获取图像数据类型的最大值和最小值
        dlimits = (np.iinfo(src.dtype).min, np.iinfo(src.dtype).max)
        # 计算低亮度像素在整个图像中的范围
        limits = np.percentile(src, [lower_percentile, upper_percentile])
        # 计算比例
        ratio = (limits[1] - limits[0]) / (dlimits[1] - dlimits[0])
        return ratio < fraction_threshold
    

    程序运行结果:
    在这里插入图片描述
    判断为低对比度图像
    在这里插入图片描述
    判断为不是低对比度图像

    展开全文
  • 数字图像处理python基础 (一)

    千次阅读 2019-01-23 17:21:05
    python图像处理基础(一) 写在前面的话: 方便以后查文档,且这篇文章会随着学习一直更(因为还有opencv还没怎么学,目前是一些基本的操作)。都是跟着学习资料巩固的,只供学习使用。 第一部分—— 图像基本操作 ...

    python图像处理基础(一)

    写在前面的话: 方便以后查文档,且这篇文章会随着学习一直更(因为还有opencv还没怎么学,目前是一些基本的操作)。都是跟着学习资料巩固的,只供学习使用。

    第一部分—— 图像基本操作

    缩略图、截图、部分变换、旋转、图像转换为数组进行操作

    • 读取图片及灰度图
    from PIL import Image #导入PIL库的Image类
    import matplotlib.pyplot as plt
    
    pil_im = Image.open('G:/photo/innovation/1.jpg') #读取图像文件
    pil_im_gray = pil_im.convert('L')
    
    plt.subplot(121)
    plt.imshow(pil_im)
    plt.subplot(122)
    plt.imshow(pil_im_gray)
    
    缩略图

    thumbnail 或 resize

    pil_im.thumbnail((128,128))
    out= pil_im.resize((128,128))
    
    截图

    (box is the crop rectangle, as a (left, upper, right, lower) tuple.)

    box=(100,100,400,400)
    region = pil_im.crop(box)
    
    部分变换

    transpose 之后 paste

    region = region.transpose(Image.ROTATE_180)
    pil_im.paste(region,box)
    
    旋转

    rotate() 传度数即可

    out = pil_im.rotate(45)
    
    图像转换为数组进行操作

    可以对数组进行任意的灰度变换后再转换为图像输出

    im = np.array(Image.open('G:/photo/innovation/1.jpg'))
    print(im.shape, im.dtype)
    pil_im = Image.fromarray(im)
    
    

    第二部分—— 图像基本处理

    灰度直方图、直方图均衡、空间滤波、图像基本变换、仿射变换

    灰度直方图

    contour作用是绘制等高线, hist 注意 im.flatten()

    from PIL import Image
    import numpy as np
    import matplotlib.pyplot as plt
    # read image to array
    im = np.array(Image.open('G:/photo/innovation/1.jpg').convert('L'))
    # create a new figure
    plt.figure()
    # don’t use colors
    plt.gray()
    # show contours with origin upper left corner
    plt.contour(im, origin='image')
    plt.axis('equal')
    plt.axis('off')
    plt.figure()
    plt.hist(im.flatten(),128)
    plt.show()
    
    直方图均衡

    c(I)=1NI=0Ih(i)=c(I1)+1Nh(I) c(I) = \frac{1}{N} * \sum_{I=0}^{I}{h(i)} = c(I - 1) + \frac{1}{N} *h(I)

    我们要对图像求直方图,就需要先把图像矩阵进行flatten操作,使之变为一维数组,然后再进行统计用reshape进行变换,实际上变换后还是二维数组,两个方括号,因此只能用 flatten.

    • cumsum(): 计算累计和
    • flatten(): 个人理解为合并列表
    • interp(): 线性插值函数
    • numpy.interp(x, xp, fp, left=None, right=None, period=None)
    
    def histeq(im,nbr_bins=256):
        """ Histogram equalization of a grayscale image. """
    
        # get image histogram
        imhist,bins = histogram(im.flatten(),nbr_bins,normed=True) 
        # 计算所有像素值
        cdf = imhist.cumsum() # cumulative distribution function 
        # 得出第一个乘数
        cdf = 255 * cdf / cdf[-1] # normalize
        
        # use linear interpolation of cdf to find new pixel values
        im2 = np.interp(im.flatten(),bins[:-1],cdf) 
        
        return im2.reshape(im.shape), cdf
    
    from PIL import Image 
    import numpy as np
    im = array(Image.open('G:/photo/innovation/1.jpg').convert('L')) 
    im2,cdf = histeq(im)
    
    plt.figure(figsize=(18,10))
    plt.subplot(231)
    plt.hist(im.flatten(),256)
    plt.subplot(232)
    plt.plot(range(256),cdf)
    plt.subplot(233)
    plt.hist(im2.flatten(),256)
    plt.subplot(234)
    plt.gray()
    plt.imshow(im)
    plt.subplot(236)
    plt.imshow(im2)
    
    plt.show()
    
    空间滤波
    • 高斯滤波 gaussian_filter
    from PIL import Image
    import numpy as np
    import matplotlib.pyplot as plt
    from scipy.ndimage import filters
    
    im = np.array(Image.open('G:/photo/innovation/1.jpg').convert('L')) 
    im2 = filters.gaussian_filter(im,5)
    pil_im2 = Image.fromarray(uint8(im2))
    plt.imshow(pil_im2)
    
    图像几何变换

    SciPy库中的ndimage包的相关函数实现几何变换,ndimage.affine_transform

    im = np.array(Image.open('G:/photo/innovation/1.jpg').convert('L'))
    H = np.array([[1.4,0.05,-100],[0.05,1.5,-100],[0,0,1]])
    im2 = ndimage.affine_transform(im,H[:2,:2],(H[0,2],H[1,2]))
    
    plt.figure()
    plt.gray()
    plt.imshow(im2)
    plt.show()
    
    仿射变换
    • 图像的坐标变换通常为仿射变换,其保留了共线性距离比例
      • 共线性:变换前在同一直线上的点变换后还在同一直线上。
      • 距离比例:变换前后直线上各点之间的距离的比例保持不变。
    • 仿射变换的一般形式

    u=c11x+c12y+c13 u = c_{11}x + c_{12}y + c_{13} v=c21x+c22y+c23 v = c_{21}x + c_{22}y + c_{23}

    • c13,c23c_{13}, c_{23}控制平移
    • c11,c12,c21,c22c_{11}, c_{12}, c_{21}, c_{22}控制缩放、旋转和剪切

    接下来将一张图进行仿射变换后贴到另一张图的指定位置

    def Haffine_from_points(fp,tp):
        """ Find H, affine transformation, such that tp is affine transf of fp. """
        
        if fp.shape != tp.shape:
            raise RuntimeError('number of points do not match')
        
        '''
        当 np.diag(array) 中,
        array是一个1维数组时,结果形成一个以一维数组为对角线元素的矩阵
        array是一个二维矩阵时,结果输出矩阵的对角线元素
        
        '''
        # condition points
        # --from points--
        m = np.mean(fp[:2], axis=1)
        maxstd = np.max(std(fp[:2], axis=1)) + 1e-9 
        C1 = np.diag([1/maxstd, 1/maxstd, 1]) 
        C1[0][2] = -m[0]/maxstd
        C1[1][2] = -m[1]/maxstd
        fp_cond = np.dot(C1,fp)
          
        # --to points--
        m = np.mean(tp[:2], axis=1)
        C2 = C1.copy() #must use same scaling for both point sets 
        C2[0][2] = -m[0]/maxstd
        C2[1][2] = -m[1]/maxstd
        tp_cond = np.dot(C2,tp)
        
        # conditioned points have mean zero, so translation is zero
        A = np.concatenate((fp_cond[:2],tp_cond[:2]), axis=0) 
        U,S,V = np.linalg.svd(A.T)
    
        # create B and C matrices as Hartley-Zisserman (2:nd ed) p 130.
        tmp = V[:2].T
        B = tmp[:2]
        C = tmp[2:4]
        
        '''
        vstack():堆栈数组垂直顺序(行)
        hstack():堆栈数组水平顺序(列)
        concatenate():连接沿现有轴的数组序列
        
        '''
        tmp2 = np.concatenate((dot(C,linalg.pinv(B)),zeros((2,1))), axis=1) 
        H = np.vstack((tmp2,[0,0,1]))
        # decondition
        H = dot(np.linalg.inv(C2),np.dot(H,C1)) 
        
        return H / H[2,2]
    
    def image_in_image(im1,im2,tp):
        """ Put im1 in im2 with an affine transformation
        such that corners are as close to tp as possible.
        tp are homogeneous and counter-clockwise from top left. """
    	
        # points to warp from
        m,n = im1.shape[:2]
        fp = np.array([[0,m,m,0],[0,0,n,n],[1,1,1,1]])
        # compute affine transform and apply
        H = Haffine_from_points(tp,fp)
    
        im1_t = ndimage.affine_transform(im1,H[:2,:2], (H[0,2],H[1,2]),im2.shape[:2])
        alpha = (im1_t > 0)
        
        return (1-alpha)*im2 + alpha*im1_t
    
    # example of affine warp of im1 onto im2
    im1 = np.array(Image.open('G:/photo/innovation/1.jpg').convert('L'))
    im2 = np.array(Image.open('G:/photo/innovation/3.jpg').convert('L'))
    
    tp = array([[158,310,304,141],[76,98,253,218],[1,1,1,1]]) 
    im3 = image_in_image(im1,im2,tp)
    plt.figure()
    plt.gray()
    plt.imshow(im3)
    plt.axis('equal')
    plt.axis('off')
    plt.show()
    
    展开全文
  • 数字图像处理python实现-形态学处理

    千次阅读 2020-02-10 13:09:30
    内容简介 腐蚀膨胀 开闭运算 轮廓提取 击中与击不中 骨架提取 细化骨架提取 细化 裁剪 距离变换骨架提取 Hilditch算法骨架提取 首先明确一点形态学操作都是针对与二值图像,在灰度图像的形态学处理也是先根据一些...
  • 图像处理Python(一)查看图像像素

    千次阅读 2018-12-20 16:36:43
    import skimage.io as io import matplotlib.pyplot as plt from PIL import Image import numpy as np import os image='/home/customer/Desktop/unet/data/membrane/train/label/1.png' img=Image.open(np.str(im....
  • 内容简介 运动模糊核方向和角度估计 最优运动模糊核长度和角度确定 运动模糊核生成 维纳滤波 运动模糊核方向和角度估计 这里介绍一种通用的做法即倒谱法如下: 这里需要注意的是... 上一篇:数字图像处理杂项-同态滤波
  • 同态滤波增强属于图像频域处理范畴,作用是对图像灰度范围进行调整,通过消除图像上照明不均匀的问题,增强图像的细节,同时对不损失亮区的图像细节。 一幅图像 能够使用它的入射光分量和反射光分量来表示 ,关系...
  • Gamma图像增强 Gamma图像增强的计算公式如下: g(x,y)=f(x,y)gamma g(x,y) = f(x,y)^{gamma} ...Python实现如下: def adjust_gamma(src,gamma=2.0): scale = float(np.iinfo(src.dtype).max - np.iinfo(src.dtyp...
  • 对数图像增强 对数图像增强的计算公式如下: (11-1)s=clog⁡(r+1) s = c \log(r + 1) \tag{11-1} ...Python实现的代码如下: def log_enhance(src): scale = float(np.iinfo(src.dtype).max - np.iinfo(src.d...
  • 图像灰度线性变换 假定原图像f(x,y)f(x,y)f(x,y)的灰度范围为[a,b],变换后图像g(x,y)g(x,y)g(x,y)灰度扩展为[c,d],则根据线性方程式可以得到: (9-1)g(x,y)=d−cb−a[f(x,y)−a]+c g(x,y) = \frac{d - c}{b - a}[f...
  • 同态滤波增强属于图像频域处理范畴,作用是对图像灰度范围进行调整,通过消除图像上照明不均匀的问题,增强图像的细节,同时对不损失亮区的图像细节。 一幅图像如果由亮度成像模型不表示,则能够使用它的入射光分量...
  • 图像尺寸调整以及保存: import os from PIL import Image filename = os.listdir("./train/main/label1/") base_dir = "./train/main/label1/" new_dir = "./train/main/label/" size_m = 800 size_n = 640 ...
  • 直方图均衡化是一种比较常用的图像处理方法,其主要作用是增加局部对比度而不失整体对比度,可以突出图像一些细节的特征。 代码实现: import numpy as np import matplotlib.pyplot as plt from PIL import ...
  • 内容简介 自适应滤波器 自适应局部降低噪声滤波 自适应中值滤波 自适应滤波器 自适应局部降低噪声滤波 先看书上的... 上一篇:数字图像处理python实现-图像去噪之空间域统计排序滤波 下一篇:数字图像处理杂项-同态滤波
  • 图像几何变换-错切变换 图像的错切变换实际上是平面景物在投影平面上的非垂直投影。错切使图像中的图形产生扭变,这种扭变只在一个方向上产生,即分别为水平错切变换和垂直错切变换。 1 水平错切变换 水平错切变换...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,192
精华内容 7,676
关键字:

图像处理python

python 订阅