精华内容
下载资源
问答
  • python2%线性拉伸

    2021-01-20 02:20:50
    核心要点 本方法是针对遥感数据的,因此使用了Gdal,如果你针对的是普通的图片,就直接使用cv2.imread()来读取即可,就不需要gdal了。 np.percentile()函数 np.clip()函数 cv2.split()函数 cv2.merge()函数 ...
  • 在ENVI里面有Linear和Linear2%的线性拉伸的方法,用的最多的就是Linear2%. Linear方法较为简单: g(x,y)=(d - c) / (b - a) * (f(x, y) + c, 其中d和c分别是输出图像的最大值和最小值,b和a分别是原始图像的最大值...

    1. 原理简介

    • 在ENVI里面有Linear和Linear2%的线性拉伸的方法,用的最多的就是Linear2%.

    • Linear方法较为简单: g(x,y)=(d - c) / (b - a) * (f(x, y) + c, 其中d和c分别是输出图像的最大值和最小值,b和a分别是原始图像的最大值和最小值,应用上式变换之后将小于c的灰度值赋值为0,大于d的灰度值赋值为255即可。

    • Linear2%方法复杂一点,原理如下:读取原始图像后首先进行直方图统计,进而计算累计直方图,假定截断值为2,然后找到2%对应的灰度值和98%对应的灰度值,将这两个值作为原始图像灰度的最大最小值,运用上述Linear方法即可得到最终结果。

    2. python实现

    import matplotlib.pyplot as plt
    import cv2
    import numpy as np
    
    def truncated_linear_stretch(image, truncated_value=2, maxout=255, min_out=0):
        def gray_process(gray, maxout=maxout, minout=min_out):
            truncated_down = np.percentile(gray, truncated_value)
            truncated_up = np.percentile(gray, 100 - truncated_value)
            gray_new = ((maxout - minout) / (truncated_up - truncated_down)) * gray
            gray_new[gray_new < minout] = minout
            gray_new[gray_new > maxout] = maxout
            return np.uint8(gray_new)
    
        (b, g, r) = cv2.split(image)
        b = gray_process(b)
        g = gray_process(g)
        r = gray_process(r)
    
        # 合并每一个通道
        result = cv2.merge((b, g, r))
        return result
    
    image = cv2.imread('image1.png')
    image_linear2 = truncated_linear_stretch(image)
    
    plt.figure()
    plt.subplot(121)
    plt.axis('off')
    plt.imshow(image)
    plt.subplot(122)
    plt.axis('off')
    plt.imshow(image_linear2)
    plt.show()
    

    img

    参考链接

    ENVI%2线性拉伸算法实现

    图像处理-线性拉伸

    调整图像亮度之 线性拉伸 (2) 百分比截断拉伸

    展开全文
  • 线性拉伸影像提升亮度,使用GDAL读取影像,做基本的线性拉伸,可以将暗色的影像变的更加清晰
  • 伽马变换就是用来图像增强,其提升了暗部细节,简单来说就是通过非线性变换,让图像从暴光强度的线性响应变得更接近人眼感受的响应,即将漂白(相机曝光)或过暗(曝光不足)的图片,进行矫正。 伽马变换的基本形式...
  • 图像处理-线性拉伸

    万次阅读 2018-05-03 16:14:13
    线性拉伸:1)直接线性拉伸;2)裁剪线性拉伸;3)分段式拉伸。1)直接线性拉伸:(直接归一化,然后放缩到指定大小范围)代码:import cv2import numpy as npgray=np.float( cv2.imread(**) )gray_new=( gray-gray....

    图像领域:拉伸即:灰度图拉伸,与直方图均衡化类似,但是也不同!!!

    线性拉伸:1)直接线性拉伸;2)裁剪线性拉伸;3)分段式拉伸。

    1)直接线性拉伸:(直接归一化,然后放缩到指定大小范围)

    代码:

    import cv2

    import numpy as np

    gray=np.float( cv2.imread(**) )

    gray_new=( gray-gray.min() ) / ( gray.max()-gray.min() ) # 归一化到0-1

    maxout=255

    minout=0

    gray_out=gray_new * (maxout -minout) # maxout=255   minout=0

    gray_out=np.uint8( gray_out )


    2)裁剪线性拉伸:(去掉2%百分位以下的数,去掉98%百分位以上的数,上下百分位数一般相同,并设置输出上下限)

    import cv2
    import numpy as np

    gray=np.float( cv2.imread(**) )

    d2=np.percentile( gray,2 )
    u98=np.percentile( gray,98 )

    maxout=255
    minout=0

    gray_new=minout + ( (gray-d2) / (u98-d2) ) * (maxout - minout)
    gray_new[gray_new < minout]=minout
    gray_new[gray_new > maxout]=maxout

    gray_out=np.uint8(gray_new)

    3)分段式 线性拉伸(百度图片)



    分段数学公式,按照公式求出前后灰度

    即: (横轴:拉伸前灰度,纵轴:拉伸后灰度,一一对应)。

    ####################################################

    envi 中对应的线性拉伸实现:

    线性拉伸 2%: 即: 2)裁剪线性拉伸

    ENVI对打开的一幅遥感影像默认是2%的线性拉伸,当然只是显示效果发生变化,亮度得到提升,但是像元值并没有发生改变;这里的Linear2%是指将直方图累积在2%至98%之间的像元值拉伸,取直方图累积在2%处对应的光谱值为MinValue,98%处对应的光谱值为MaxValue,那么可解释为如果像元值大于MinValue且小于MaxValue,则将其拉伸至0-255;如果像元值小于MinValue,那么将其改为MinValue;如果像元值大于MaxValue,那么将其改为255。


    线性拉伸 0-255:即:1)直接线性拉伸


    ####################################################


    展开全文
  • Python 标准差拉伸

    2020-05-10 15:58:37
    记录日常Python脚本标准差拉伸16bit转为8bit 标准差拉伸16bit转为8bit 代码如下. # -*- coding: utf-8 -*- from osgeo import gdal import numpy as np import os def Bit8(RawBandData, dMin, dMax, Mean, StdDev...

    Python Gdal 标准差拉伸

    16bit转为8bit

    ,代码如下.

    # -*- coding: utf-8 -*-
    import os
    
    from osgeo import gdal
    import numpy as np
    
    
    def Bit8(RawBandData, dMin, dMax, Mean, StdDev, Kn):
        ucMax = Mean + Kn * StdDev
        ucMin = Mean - Kn * StdDev
        k = (dMax - dMin) / (ucMax - ucMin)
        b = (ucMax * dMin - ucMin * dMax) / (ucMax - ucMin)
        if (ucMin <= 0):
            ucMin = 0
    
        RawBandData = np.select([RawBandData==dMin, RawBandData<=ucMin, RawBandData>=ucMax, k*RawBandData+b < dMin, k*RawBandData+b > dMax ,
                                 (k*RawBandData+b > dMin) & (k*RawBandData+b < dMax)],
                                [dMin, dMin, dMax, dMin, dMax, k * RawBandData + b], RawBandData)
        return RawBandData
    
    
    def convert2bit8(InPath):
        if not os.path.exists(InPath):
            print('输入路径不存在!')
            return None
        for root, dirs, files in os.walk(InPath):
            for file in files:
                '''筛选tif文件'''
                if not file.split('.')[-1] == 'tif':
                    continue
                '''输入路径的文件名'''
                file_name = os.path.join(root, file)
                '''创建输出路径文件名'''
                OutFile = os.path.join(root, os.path.splitext(file)[0] + '_Bit8.tif')
                '''文件存在则删除文件重新生成'''
                if os.path.exists(OutFile):
                    os.remove(OutFile)
                InTif = gdal.Open(file_name)
                Width = InTif.RasterXSize
                Height = InTif.RasterYSize
    
                '''跳过8bit'''
                if InTif.ReadAsArray().dtype.name == 'uint8':
                    continue
    
                geoTransform = InTif.GetGeoTransform()
                print('左上角坐标 %f %f' % (geoTransform[0], geoTransform[3]))
                print('像素分辨率 %f %f' % (geoTransform[1], geoTransform[5]))
                '''True Color 1,2,3波段'''
                OutTif = gdal.GetDriverByName('GTiff').Create(OutFile, Width, Height, InTif.RasterCount, gdal.GDT_Byte)
                OutTif.SetProjection(InTif.GetProjection())
                OutTif.SetGeoTransform(geoTransform)
    
                for i in range(1, int(InTif.RasterCount) + 1):
                    RawBand = InTif.GetRasterBand(i)
                    RawBandData = RawBand.ReadAsArray()
                    Mean = np.mean(RawBandData)
                    StdDev = np.std(RawBandData, ddof=1)
                    # StdDev = np.std(RawBandData)
                    OutBand = Bit8(RawBandData, 0, 255, Mean, StdDev, 2.5)
                    OutTif.GetRasterBand(i).WriteArray(OutBand)
    
                OutTif.FlushCache()
                for i in range(1, int(InTif.RasterCount) + 1):
                    OutTif.GetRasterBand(i).ComputeStatistics(False)
                OutTif.BuildOverviews('average', [2, 4, 8, 16, 32])
                del OutTif
        return OutFile
    
    
    if __name__ == '__main__':
        '''输入路径'''
        InPath = r"D:\Data\hsd\201911\01\YT"
    
        convert2bit8(InPath)
    
    
    展开全文
  • 实现伽马校正(非线性) 实现对比度和亮度校正(线性) 色彩空间转化 RGB 2 HSV 伪彩色变化 用了一整天时间,记录下做的过程中遇到的坑 实验总结 载入图像时,可以对载入是否成功进行判断,有利于自己检查问题,...

    实验目标

    1. 完成图像的载入和显示
    2. RGB三通道分离并显示
    3. RGB三通道均衡化并显示
    4. 实现锐化
    5. 实现伽马校正(非线性)
    6. 实现对比度和亮度校正(线性)
    7. 色彩空间转化 RGB 2 HSV
    8. 伪彩色变化

    实验效果

    亮度对比度调整——线性校正(下图)
    亮度对比度调整——线性校正
    伽马校正——非线性校正(下图)
    在这里插入图片描述

    实验代码

    # 关于版本
    # numpy            1.16.6
    # opencv-python    4.2.0.34
    import cv2 as cv
    import numpy as np
    # 导入图像
    srcImage = cv.imread('C:\\Users\\MRSANG\\Desktop\\CV_test\\test_1\\1.jpg')
    if srcImage is None:
        print('Could not open or find the image: ')
        exit(0)
    else:
        print('loading ... successfully')
    cv.imshow('origin_win', srcImage)
    # rgb三通道分离 并显示
    ori_channel_r, ori_channel_g, ori_channel_b = cv.split(srcImage)
    
    cv.imshow("ori_channel_r", ori_channel_r)
    cv.imshow("ori_channel_g", ori_channel_g)
    cv.imshow("ori_channel_b", ori_channel_b)
    
    # rgb三通道均衡化
    equ_channel_r = cv.equalizeHist(ori_channel_r)
    equ_channel_g = cv.equalizeHist(ori_channel_g)
    equ_channel_b = cv.equalizeHist(ori_channel_b)
    equ_Image = cv.merge((equ_channel_r, equ_channel_g, equ_channel_b))
    # 均衡化显示
    cv.imshow('equalizeHistImage', equ_Image)
    # 锐化
    sharp_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
    sharp_image = cv.filter2D(srcImage, ddepth=-1, kernel=sharp_kernel)
    # 锐化显示
    cv.imshow('sharp_image', sharp_image)
    
    # 伽马矫正以及亮度对比度调整
    img2 = np.copy(srcImage)
    img2_winname = 'srcImage2'
    img3 = np.copy(srcImage)
    print(img3)
    img3_winname = 'srcImage3'
    cv.imshow(img2_winname, img2)
    cv.imshow(img3_winname, img3)
    
    
    # 伽马和亮度对比度的回调函数
    def gamma_function(x):
        fGamma = cv.getTrackbarPos('gamma', img2_winname) / 50
        # 打印gamma的值
        # print(cv.getTrackbarPos('gamma', 'srcImage_copy'))
        img2_copy = np.array(pow(img2/255, fGamma) * 255, dtype='uint8')
        cv.imshow(img2_winname, img2_copy)
        print('gamma:{}'.format(fGamma)) # 输出gamma比例值
        print(' - - - - - -')
    
    
    def contrast_function(x):
        f_alpha = cv.getTrackbarPos('alpha', img3_winname)/10.0
        f_beta = cv.getTrackbarPos('beta', img3_winname)
        # img3_copy = np.array((f_alpha * img3 + f_beta), dtype='uint8') # 这样会导致>255像素的高位被砍掉,导致图像展示的奇奇怪怪
        img3_copy = np.array(np.clip(f_alpha * img3 + f_beta, 0, 255), dtype=np.uint8)
        cv.imshow(img3_winname, img3_copy)
        print('alpha:{}'.format(f_alpha))  # 输出alpha比例值
        print('beta:{}'.format(f_beta))  # 输出beta值
        print(' - - - - - -')
    
    
    # 创建滑动条
    cv.createTrackbar('gamma', img2_winname, 50, 100, gamma_function) # gamma
    cv.createTrackbar('alpha', img3_winname, 10, 30, contrast_function) # contrast
    cv.createTrackbar('beta', img3_winname, 0, 200, contrast_function) # brightness
    
    # RGB2HSV 导入图像
    Color_CvtImg = cv.imread('C:\\Users\\MRSANG\\Desktop\\CV_test\\test_1\\2.bmp')
    Color_CvtImg2 = cv.cvtColor(Color_CvtImg, cv.COLOR_BGR2HSV)
    # 色彩空间分离并转换
    Color_H, Color_S, Color_V = cv.split(Color_CvtImg)
    cv.imshow('Cvt_H', Color_H)
    cv.imshow('Cvt_S', Color_S)
    cv.imshow('Cvt_V', Color_V)
    
    # 伪彩色变化
    FColor_Src = cv.imread('C:\\Users\\MRSANG\\Desktop\\CV_test\\test_1\\3.jpg', cv.IMREAD_GRAYSCALE)
    FColor_Img = cv.applyColorMap(FColor_Src, cv.COLORMAP_JET)
    cv.imshow('FColor_Img', FColor_Img)
    cv.waitKey(0)
    

    实验总结

    用了一整天时间,记录下做的过程中遇到的坑

    1. 载入图像时,可以对载入是否成功进行判断,有利于自己检查问题,图片路径采用绝对路径好一些,记得路径中要改为“ \” 或者 “/”
    2. 当准备更改图像的像素值的时候(比如伽马校正),需要对所有像素点先遍历后更改,如果采用三个for循环,速度会非常慢,此时考虑图像已经是矩阵的形式,可以直接把图像所代表的矩阵放入伽马函数的表达式中,处理速度会大大加快。需要特别注意,不要把创建大矩阵(np.array),或者矩阵修改这样的操作放在循环里

    逐个像素点遍历,速度非常慢

        for i in range(256):
            lut.append(pow((i/255.0), fGamma) * 255.0)
            np.array(lut)
        for x in range(img2.shape[0]):  # 图片的高
            for y in range(img2.shape[1]):  # 图片的宽
                for z in range(img2.shape[2]): # 每一个通道
                    img3[x, y, z] = lut[img3[x, y, z]]
    

    带入伽马函数的计算公式,响应很快(因为图像本质上是数组)

    	img2_copy = np.array(pow(img2/255, fGamma) * 255, dtype='uint8')
    

    (此处有个小细节,关于图像整型,浮点型,关于uint8的对显示影响的问题,另开一文做记录)

    1. 当展示的窗口太多时,如果每一个窗口都是采用临时命名的形式,当需要修改(或者需要调用窗口名)时,会非常麻烦,如果有一个忘记改了,显示都会不正常
    	cv.imshow('srcImage_copy', img3)
    

    可以提前定义好字符串,窗口名称填入字符串,方便修改

    1. 定义核函数时,使用np.array,注意数组的定义形式,[]和()注意规则,很容易弄错。此处参考博客:np.array定义的使用
    2. 对图像像素值进行修改时(比如锐化,伽马校正),如果直接在原图上更改,像素值一旦更改是不可逆的,所以提前copy一份,会很方便
    展开全文
  • 16位遥感图像转8位显示 %2线性拉伸

    千次阅读 2017-10-28 14:34:55
    import cv2 import gdal import numpy as np #计算2% 98%处值作为最小 最大值 def minmaximg(width,heigh,img): img_fla = img.flatten() #展成一维数组 #img_fla = np.sort(img_fla) #排序 ...
  • 目录分段线性变换对比度拉伸最大最小值拉伸 分段线性变换 优点 形式可以任意复杂 缺点 要求用户输入很多参数 对比度拉伸 光照不足、成像传感器的动态范围偏小、图像获取过程中镜头孔径的设置错误 点(r1,s1...
  • Python OpenCV实例:图像灰度拉伸

    千次阅读 2018-04-19 17:13:00
    定义:灰度拉伸,也称对比度拉伸,是一种简单的线性点运算。作用:扩展图像的 直方图,使其充满整个灰度等级范围内 公式: g(x,y) = 255 / (B - A) * [f(x,y) - A], 其中,A = min[f(x,y)],最...
  • 本专栏主要介绍如果通过OpenCv-Python进行图像处理,通过原理理解OpenCv-Python的函数处理原型,在具体情况中,针对不同的图像进行不同等级的、不同方法的处理,以达到对图像进行去噪、锐化等一系列的操作。...
  • return tab.astype(np.uint64).tolist() def image_stretch(img): # 图像拉伸 minimum = img.min() maximum = img.max() a = 255/(maximum-minimum) b = -255*minimum/(maximum-minimum) return (a*img+b).astype...
  • 遥感图像拉伸显示# 因为遥感图像数据位数是16位(uint16),需要使用5%的线性拉伸,不然显示起来不正常def stretch_n(bands, lower_percent=5, higher_percent=95): # print(bands.dtype) # 一定要使用float32类型,...
  • 书籍:机器学习线性代数基础——Python语言描述 机器学习线性代数基础——Python语言描述第一章:坐标与变换1.1 描述空间的工具:向量 第一章:坐标与变换 1.1 描述空间的工具:向量 概念:把一组数字排列成一行或...
  • GDAL调整图像亮度之百分比截断拉伸。简介百分比截断拉伸原理,以及验证过的核心代码,相关注释,效果图
  • 图像灰度线性变换 假定原图像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...
  • 对比度拉伸是扩展图像灰度级动态范围的处理。通过在灰度级中确定两个点来控制变换函数的形状。下面是对比度拉伸函数中阈值处理的代码示例,阈值为平均值。 2. 测试结果 图源自skimage 3. 代码 1 def ...
  • 主要介绍了Numpy一维线性插值函数的用法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 2 线性灰度变换­—图像反转 3 非线性灰度变换 3.1 对数变换 3.2 伽马变换 参考资料 1 灰度变换简介 灰度变换是图像增强的一种重要手段,用于改善图像显示效果,属于空间域处理方法,它可以使图像动态范围加大...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,659
精华内容 663
关键字:

python线性拉伸

python 订阅