精华内容
下载资源
问答
  • 灰度拉伸算法

    2017-11-27 17:07:35
    该算法主要是在图像处理过程中对图像灰度进行拉伸处理。
  • 数字图像的灰度拉伸

    2021-02-14 10:37:40
    通过灰度拉伸可加大图像的对比度,使图像变得更加清晰。 灰度拉伸分为线性拉伸和非线性拉伸两种方法。 1、线性拉伸对像素值进行线性比例变化,主要有以下几种方法: 全域线性拉伸 2%线性拉伸 分段线性拉伸 ...

    成像系统只能获取一定亮度范围内的值。由于成像系统的量化级数有限,常出现对比度不足的弊病,图像看起来比较模糊、暗淡。通过灰度拉伸可加大图像的对比度,使图像变得更加清晰。

    灰度拉伸分为线性拉伸和非线性拉伸两种方法。

    1、线性拉伸对像素值进行线性比例变化,主要有以下几种方法:

    • 全域线性拉伸
    • 2%线性拉伸
    • 分段线性拉伸
    • 灰度窗口切片(可将某一区间内的灰度级和其他部分分开)

    2、非线性拉伸使用非线性函数对图像进行拉伸变化,常用的非线性函数有指数函数、对数函数、平方根、高斯函数等。其中,指数变换对于图像中亮的部分,它扩大了灰度间隔,突出了细节;对于暗的部分,它缩小了灰度间隔,弱化了细节。与指数变换相反,对数变换主要用于拉伸图像中暗的部分,而压缩亮的部分。

    展开全文
  • 图像灰度拉神,主要是将图像的灰度拉伸至全灰度区间,计算公式如下: xaml代码 <Window x:Class="ImageProcess_GrayStretch.MainWindow" xmlns=...

    图像灰度拉神,主要是将图像的灰度拉伸至全灰度区间,计算公式如下:

     

    •  xaml代码
    <Window x:Class="ImageProcess_GrayStretch.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:ImageProcess_GrayStretch"
            mc:Ignorable="d"
            Title="MainWindow" Height="450" Width="800">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition/>
                <RowDefinition Height="auto"/>
            </Grid.RowDefinitions>
            <Image Name="img" Stretch="Uniform"/>
            <StackPanel Grid.Row="1" Orientation="Horizontal">
                <Button Content="Load Bitmap" Margin="5" Click="Load_Click"/>
                <Button Content="Gray Stretch" Margin="5" Click="GrayStretch_Click"/>
            </StackPanel>
        </Grid>
    </Window>
    
    • 后台代码
    using System;
    using System.Drawing;
    using System.Drawing.Imaging;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.Windows;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    
    namespace ImageProcess_GrayStretch
    {
        /// <summary>
        /// MainWindow.xaml 的交互逻辑
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
            }
    
            private byte GetMaxValue(byte[] rgbValues)
            {
                byte maxi = rgbValues[0];
                for (int i = 0; i < rgbValues.Length; i++)
                {
                    if (maxi < rgbValues[i])
                    {
                        maxi = rgbValues[i];
                    }
                }
                return maxi;
            }
    
            private byte GetMinValue(byte[] rgbValues)
            {
                byte mini = rgbValues[0];
                for (int i = 0; i < rgbValues.Length; i++)
                {
                    if (mini > rgbValues[i])
                    {
                        mini = rgbValues[i];
                    }
                }
                return mini;
            }
    
            private void BitmapGrayStretch(Bitmap curBitmap, int width, int height)
            {
                System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, width, height);
                BitmapData bmpData = curBitmap.LockBits(rect, ImageLockMode.ReadWrite, curBitmap.PixelFormat);
                IntPtr ptr = bmpData.Scan0;
                int bytes = width * height * 4;
                byte[] rgbValues = new byte[bytes];
                Marshal.Copy(ptr, rgbValues, 0, bytes);
                byte[] matGray = new byte[width * height];
                for (int i = 0; i < rgbValues.Length; i = i + 4)
                {
                    byte alpha = rgbValues[i + 3];
                    byte red = rgbValues[i + 2];
                    byte green = rgbValues[i + 1];
                    byte blue = rgbValues[i];
                    byte gray = (byte)(red * 0.299 + green * 0.587 + blue * 0.114);
                    matGray[i / 4] = gray;
                }
                byte maxGray = GetMaxValue(matGray);
                byte minGray = GetMinValue(matGray);
                double f = 0;
                if (maxGray != minGray)
                {
                    f = 255.0 / (maxGray - minGray);
                }
                for (int i = 0; i < rgbValues.Length; i = i + 4)
                {
                    rgbValues[i] = (byte)(f * (matGray[i / 4] - minGray));
                    rgbValues[i + 1] = (byte)(f * (matGray[i / 4] - minGray));
                    rgbValues[i + 2] = (byte)(f * (matGray[i / 4] - minGray));
                }
                Marshal.Copy(rgbValues, 0, ptr, bytes);
                curBitmap.UnlockBits(bmpData);
            }
    
            private Bitmap ImageSourceToBitmap(ImageSource imageSource)
            {
                BitmapSource bitmapSource = (BitmapSource)imageSource;
                Bitmap bmp = new Bitmap(bitmapSource.PixelWidth, bitmapSource.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
                BitmapData data = bmp.LockBits(
                    new System.Drawing.Rectangle(System.Drawing.Point.Empty, bmp.Size), ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
                bitmapSource.CopyPixels(Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
                bmp.UnlockBits(data);
                return bmp;
            }
    
            private BitmapImage BitmapToBitmapImage(Bitmap bitmap)
            {
                using (MemoryStream stream = new MemoryStream())
                {
                    bitmap.Save(stream, ImageFormat.Png);
                    stream.Position = 0;
                    BitmapImage result = new BitmapImage();
                    result.BeginInit();
                    result.CacheOption = BitmapCacheOption.OnLoad;
                    result.StreamSource = stream;
                    result.EndInit();
                    result.Freeze();
                    return result;
                }
            }
    
            private void Load_Click(object sender, RoutedEventArgs e)
            {
                img.Source = new BitmapImage(new Uri(@"D:\程序项目目录\ImgList\World.jpg", UriKind.RelativeOrAbsolute));
            }
    
            private void GrayStretch_Click(object sender, RoutedEventArgs e)
            {
                Bitmap bitmap = ImageSourceToBitmap(img.Source);
                BitmapGrayStretch(bitmap, bitmap.Width, bitmap.Height);
                img.Source = BitmapToBitmapImage(bitmap);
            }
        }
    }
    

    技术要领: 采用内存方式一次性加载整个图片,效率高,如果用循环的方式,采用GetPixel方式来获取像素RGB值,效率极低,这幅图片的size为2048*1025,循环方式特别慢。

    展开全文
  • Python OpenCV实例:图像灰度拉伸

    千次阅读 2018-04-19 17:13:00
    灰度拉伸 定义:灰度拉伸,也称对比度拉伸,是一种简单的线性点运算。作用:扩展图像的 直方图,使其充满整个灰度等级范围内 公式: g(x,y) = 255 / (B - A) * [f(x,y) - A], 其中,A = min[f(x,y)],最...
    #coding:utf-8
    '''
    灰度拉伸
    定义:灰度拉伸,也称对比度拉伸,是一种简单的线性点运算。作用:扩展图像的
          直方图,使其充满整个灰度等级范围内
    公式:
    g(x,y) = 255 / (B - A) * [f(x,y) - A],
    其中,A = min[f(x,y)],最小灰度级;B = max[f(x,y)],最大灰度级;
         f(x,y)为输入图像,g(x,y)为输出图像
    
    缺点:如果灰度图像中最小值A=0,最大值B=255,则图像没有什么改变
    
    '''
    
    import cv2
    import numpy as np
    
    def grey_scale(image):
        img_gray = cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)
        
        rows,cols = img_gray.shape
        flat_gray = img_gray.reshape((cols * rows,)).tolist()
        A = min(flat_gray)
        B = max(flat_gray)
        print('A = %d,B = %d' %(A,B))
        output = np.uint8(255 / (B - A) * (img_gray - A) + 0.5)
        return output
    
    src = cv2.imread('datas/f4.jpg')
    result = grey_scale(src)
    cv2.imshow('src',cv2.cvtColor(src,cv2.COLOR_BGR2GRAY))
    cv2.imshow('result',result)
    
    cv2.waitKey()
    cv2.destroyAllWindows()

    171256_khyh_106657.png

     

    展开全文
  • [数字图像处理]灰度变换——反转,对数变换,伽马变换,灰度拉伸,灰度切割,位图切割 【From】http://blog.csdn.net/zhoufan900428/article/details/12709361 数字图像处理灰度变换灰度拉伸MATLAB...

    [数字图像处理]灰度变换——反转,对数变换,伽马变换,灰度拉伸,灰度切割,位图切割

    【From】http://blog.csdn.net/zhoufan900428/article/details/12709361

    目录(?)[+]

                灰度变换,属于一个非常重要的概念。这里主要参考《Digital Image Processing》 Rafael C. Gonzalez / Richard E. Woods 的第三章。书中所有的实验与数学式都采用了8-bit 图像的灰度范围,也就是0到255这样一个范围,这是本书不合理的一个地方。首先,这样做并不泛用,图片不一定是8-bit的。其次,在做某些变换的时候,可能会导致溢出。比如,伽马变化,假设伽马值为2,那么灰度为255的像素点,其变换之后值为65025,这里就溢出了。当然,要是使用Matlab计算,肯定会处理的非常好,直接使用mat2gray函数就能将其压缩回0到255。但是要是其他嵌入式平台处理的时候,直接套用不方便不说,直接按照8-bit的图来理解很不直观。因此,我将数学式做了改变,让其输入为0到1的浮点数,其输出也是0到1的浮点数,这样方便理解。

          本文所使用的图片,均来源于《Digital Image Processing》的主页 http://www.imageprocessingplace.com/

           图像反转

           图像反转,这个翻译还是很不恰当的。这里应该理解为负片变换,负片变换如下所示。

    负片变换,主要用于观察过黑的图片,负片变换之后,方便观察。很简单的变换。

           对数变换

           对数变换主要用于将图像的低灰度值部分扩展,将其高灰度值部分压缩,以达到强调图像低灰度部分的目的。变换方法由下式给出。

    这里的对数变换,底数为,实际计算的时候,需要用换底公式。其输入为,其输出也为。对于不同的底数,其对应的变换曲线如下图所示。

    底数越大,对低灰度部分的强调就越强,对高灰度部分的压缩也就越强。相反的,如果想强调高灰度部分,则用反对数函数就可以了。看下面的实验就可以很直观的理解,下图是某图像的二维傅里叶变换图像,其为了使其灰度部分较为明显,一般都会使用灰度变换处理一下。

           实现对数变换的Matlab代码如下:
    [plain]  view plain copy
    1. close all;  
    2. clear all;  
    3.   
    4. %% -------------Log Transformations-----------------  
    5. f = imread('DFT_no_log.tif');  
    6. f = mat2gray(f,[0 255]);  
    7.   
    8. v = 10;  
    9. g_1 = log2(1 + v*f)/log2(v+1);  
    10.   
    11. v = 30;  
    12. g_2 = log2(1 + v*f)/log2(v+1);  
    13.   
    14. v = 200;  
    15. g_3 = log2(1 + v*f)/log2(v+1);  
    16.   
    17. figure();  
    18. subplot(1,2,1);  
    19. imshow(f,[0 1]);  
    20. xlabel('a).Original Image');  
    21. subplot(1,2,2);  
    22. imshow(g_1,[0 1]);  
    23. xlabel('b).Log Transformations v=10');  
    24.   
    25. figure();  
    26. subplot(1,2,1);  
    27. imshow(g_2,[0 1]);  
    28. xlabel('c).Log Transformations v=100');  
    29.   
    30. subplot(1,2,2);  
    31. imshow(g_3,[0 1]);  
    32. xlabel('d).Log Transformations v=200');  

           伽马变换

           伽马变换主要用于图像的校正,将漂白的图片或者是过黑的图片,进行修正。伽马变换也常常用于显示屏的校正,这是一个非常常用的变换。其变化所用数学式如下所示,

    其输入为,其输出也为。对于不同的伽马值,其对应的变换曲线如下图所示。

    和对数变换一样,伽马变换可以强调图像的某个部分。根据下面两个实验,可以看出伽马变换的作用。
           实验1:

    其实现Matlab代码为:
    [plain]  view plain copy
    1. close all;  
    2. clear all;  
    3.   
    4. %% -------------Gamma Transformations-----------------  
    5. f = imread('fractured_spine.tif');  
    6. f = mat2gray(f,[0 255]);  
    7.   
    8. C = 1;  
    9. Gamma = 0.4;  
    10. g2 = C*(f.^Gamma);  
    11.   
    12. figure();  
    13. subplot(1,2,1);  
    14. imshow(f,[0 1]);  
    15. xlabel('a).Original Image');  
    16.   
    17. subplot(1,2,2);  
    18. imshow(g2,[0 1]);  
    19. xlabel('b).Gamma Transformations \gamma = 0.4');  
           实验2:

           灰度拉伸

           灰度拉伸也用于强调图像的某个部分,与伽马变换与对数变换不同的是,灰度拉升可以改善图像的动态范围。可以将原来低对比度的图像拉伸为高对比度图像。实现灰度拉升的方法很多,其中最简单的一种就是线性拉伸。而这里介绍的方法稍微复杂一些。灰度拉伸所用数学式如下所示。

    同样的,其输入为,其输出也为。这个式子再熟悉不过了,跟巴特沃斯高通滤波器像极了,其输入输出关系也大致能猜到是个什么形状的。但是,这里就出现一个问题了,输入为0时候,式子无意义了。所以,在用Matlab计算的时候,将其变为如下形式。

    这里的eps,就是Matlab里面,一个很小数。如此做的话,式子变得有意义了。但是,其输入范围为的时候,其输出范围变为了。输出范围大致为,为了精确起见,使用mat2gray函数将其扩展到精确的。调用格式如下。
    [plain]  view plain copy
    1. g = mat2gray(g,[1/(1+(m/eps)^E) 1/(1+(m/1+eps)^E)]);  
           输入输出问题解决了,还有一个问题,参数的决定。这里有两个参数,一个是m(相对于巴特沃斯高通滤波器而言,这个是截止频率),一个是E(相对于 巴特沃斯高通滤波器而言,这个是滤波器次数)。m可以控制变换曲线的重心,E则可以控制曲线的斜率,如下图所示。

    m值的可取图像灰度分布的中央值,如下式所示,

           决定m之后,接下来就只剩E了。灰度拉升的目的就是扩展图片的动态范围,我们想将原本灰度范围是的图像变换到内。那么,就直接取最大值与最小值,带入式子,解出E就可以了。但是,如之前所说的,我们所用的式子的的输出范围达不到,而且,直接取的范围,会造成E非常大,从而变换曲线的斜率非常大,灰度扩展的结果并不是很好。所以,这里退一步,取的输出范围是。E的取值,如下所示。

           实验:

           从直方图看,原图的灰度范围确实被拉伸了。用上面所说的方法,确定的灰度拉伸的输入输出曲线如下图所示。

          其Matlab代码如下:
    [plain]  view plain copy
    1. close all;  
    2. clear all;  
    3.   
    4. %% -------------Contrast Stretching-----------------  
    5. f = imread('washed_out_pollen_image.tif');  
    6. %f = imread('einstein_orig.tif');  
    7. f = mat2gray(f,[0 255]);  
    8.   
    9. [M,N] = size(f);  
    10. g = zeros(M,N);  
    11.   
    12. Min_f = min(min(f));  
    13. Max_f = max(max(f));  
    14. m = (Min_f + Max_f)/2;  
    15.   
    16. Out_put_min = 0.05;  
    17. Out_put_max = 0.95;  
    18.   
    19. E_1 = log(1/Out_put_min - 1)/log(m/(Min_f+eps));  
    20. E_2 = log(1/Out_put_max - 1)/log(m/(Max_f+eps));  
    21. E = ceil(min(E_1,E_2)-1);  
    22.   
    23. g = 1 ./(1 + (m ./ (f+ eps)).^E);  
    24. g = mat2gray(g,[1/(1+(m/eps)^E) 1/(1+(m/1+eps)^E)]);  
    25.   
    26. figure();  
    27. subplot(2,2,1);  
    28. imshow(f,[0 1]);  
    29. xlabel('a).Original Image');  
    30.   
    31. subplot(2,2,2);  
    32. r = imhist(f)/(M*N);  
    33. bar(0:1/255:1,r);  
    34. axis([0 1 0 max(r)]);  
    35. xlabel('b).The Histogram of a');  
    36. ylabel('Number of pixels');  
    37.   
    38. subplot(2,2,3);  
    39. imshow(g,[0 1]);  
    40. xlabel('c).Results of Contrast stretching');  
    41.   
    42. subplot(2,2,4);  
    43. s = imhist(g)/(M*N);  
    44. bar(0:1/255:1,s);  
    45. axis([0 1 0 max(s)]);  
    46. xlabel('b).The Histogram of a');  
    47. ylabel('Number of pixels');  
    48.   
    49. in_put = 0:1/255:1;  
    50. Out_put1 = 1 ./(1 + (m ./ (double(in_put)+ eps)).^E);  
    51. Out_put1 = mat2gray(Out_put1,[1/(1+(m/eps)^E) 1/(1+(m/1+eps)^E)]);  
    52.   
    53. figure();  
    54. plot(in_put,Out_put1);  
    55. axis([0,1,0,1]),grid;  
    56. axis square;  
    57. xlabel('Input intensity level');  
    58. ylabel('Onput intensity level');  

           灰度切割

           灰度切割也是一个很简单,但也很实用的变换。灰度切割,主要用于强调图像的某一部份,将这个部分赋为一个较高的灰度值,其变换对应关系如下所示。

    灰度切割有以上两种方法,一种是特定灰度值的部分赋值为一个较高的灰度值,其余部分为一个较低的灰度值。这样的方法,得到的结果是一个二值化图像。另外一种方法,则是仅仅强调部分赋值为一个较高的灰度值,其余的部分不变。
           实验:

           位图切割

           位图切割,就是按照图像的位,将图像分层处理。若图像的某个像素,其bit7为1,则在位面7这个像素值为1,反之则为0。
           实验:

           由位图切割的结果,图像的主要信息包含在了高4位。仅仅靠高4位,还原的图像更原图基本差不多。由此可见,位图切割主要用于图像压缩。
    展开全文
  • 【图像处理】-004 图像灰度拉伸

    千次阅读 2018-12-11 13:58:45
    图像灰度拉伸 文章目录1 原理2 Matlab实现3 OpenCV实现4 效果 1 原理   图像灰度拉伸是改变图像对比度的一种方法,通过灰度映射,将原图中某一区段中的灰度值映射到另一灰度值,从而拉伸或压缩整个图像的灰度...
  • 灰度拉伸,与线性变换有点类似(可参考:灰度线性变换之c++实现(qt + 不调包)),不同之处在于灰度拉伸使用的是分段线性变换,所以它最大的优势是变换函数可以由用户任意合成。其公式如下图,其中x为输入像素值,...
  • Java读入一张图,将其压缩至指定大小后转化为灰度图,然后对灰度图作直方图均衡和灰度拉伸,文末附代码。
  • 灰度拉伸也属于线性点运算的一种,也可以通过上一节的程序得到。但由于它在点运算的特殊性,所以把它单独列出来进行介绍。 灰度拉伸定义 如果一幅图像的灰度值分布在全等级灰度范围内,即在0~255之间,那么它更容易被...
  • 一、基本知识 图像对比度是指:一副图像中明暗区域最亮的白和最暗的黑之间不同亮度层级的测量,差异范围越大代表对比度越大;一般来说图像对比度越大,图像越清晰醒目,色彩也越鲜明...直方图均衡化以及灰度拉伸都...
  • 图像处理-基本算法之灰度拉伸

    千次阅读 2012-06-13 13:00:55
    灰度拉伸是图像增强的一种,它是把分离的灰度转换到比较集中的程度,这时就更利于分析。  代码如下: [cpp] view plaincopyprint? /*************************************************************...
  • 算法原理1.直方图均衡直方图均衡化的基本思想是把原始图像的直方图变换为均匀分布的形式。这样增加了灰度值的动态范围,从而... p(i)=nin,i=0,1,...,L−1(L:灰度级个数)p(i)=\frac{n_i}{n},i=0,1,...,L-1 (L:灰度级个
  • 灰度变换,属于一个非常重要的概念。这里主要参考《Digital Image Processing》 Rafael C. Gonzalez / Richard E. Woods 的第三章。书中所有的实验与数学式都采用了8-bit 图像的灰度范围,也就是0到255这样一个范围...
  • 灰度图像拉伸方法

    千次阅读 2016-08-11 19:22:04
    方法原理: 1.找到该灰度图像灰度值的最大值(max_value)和最小值(min_value) ...3.遍历灰度图像(image)得到拉伸后的灰度图像 公式如下: image[i] = HistogramStrench_min + (((image[i] - min_value) *
  • 注:作者辛苦原创,转载请注明出处imadjust函数是MATLAB的一个工具箱函数,一般的语法调用格式为:f1=imadjust(f,[low_inhigh_in],[low_...把图像f灰度变换到新图像f1的过程中,f中灰度值低于low_in的像素点在...
  • 灰度图像直方图均衡化公式及实现

    万次阅读 2018-01-28 17:35:08
    灰度图像直方图均衡化公式及实现
  • 这段程序是对灰度图像进行非线性拉伸,即讲灰度图像的灰度分段,分为三段,低灰度级,中灰度级,高灰度级,把三段灰度级进行灰度压缩,使得亮的地方更亮,暗的地方更暗,这样可以增加灰度的对比度,便于目标跟踪。
  • 对数与对比度拉伸变换是进行动态范围处理的基本工具 对数变换的表达式:g = c*log(1+f),主要应用压缩动态范围 其中c是一个常数,f是浮点数, 图像类似: gamma曲线的形状可变,但是对数形状是固定的 当执行...
  • 实验内容及实验原理:1、灰度的线性变换灰度的线性变换就是将图像中所有的点的灰度按照线性灰度变换函数进行变换。该线性灰度变换函数是一个一维线性函数:f(x)=a*x+b其中参数a为线性函数的...2、灰度拉伸灰度拉伸和...
  • 点运算又称为对比度增强、对比度拉伸灰度变换,是一种通过图像中的每一个像素值进行运算的图像处理方式。。它将输入图像映射为输出图像,输出图像每个像素点的灰度值仅有对应的输入像素点的灰度值决定,运算结果...
  • 题目:定义一个图像的对比度拉伸函数,函数名为myGrayScaleTransform,将输入图像的对比度线性平滑地拉伸到指定的灰度级区间,要求该函数的输入参数包括处理前的灰度图像img1 (如EXP1A.tif)、期望灰度级的参数区间...
  • 这次我们要处理的是对图像进行旋转操作,具体要求,如下:  自定义一个图像的... 曾参考《数字图像处理(第三版)》一书中P51的公式编写过自己的图像“旋转”函数,但是在某些角度下,输出结果却发生了错误,至于
  • 图像的灰度变换——图像旋转 图像的反色处理 对比度拉伸
  • 图像灰度归一化

    千次阅读 2019-12-05 18:05:14
    cv::normalize(src, dst, 0, 255, NORMAL_MINMAX) 将灰度拉伸到0~255之间 cv::normalize(src, dst, 0, 1, NORMAL_MINMAX) 将灰度归一化到0~1之间
  • 拉伸低对比度图像、过度曝光图像,观察图像变换,对图像直方图均衡算法一、在开始之前知识点二、开始三、灰度拉伸,观察它们的图像变化、直方图变化1、先对 一副低对比度图像 灰度拉伸2、观察图像变化、直方图变化3...
  • 灰度变换_MATLAB

    千次阅读 2017-05-23 16:14:59
    介绍一些基本的绘图方法和灰度变换函数,对imadjust()和strtchlim()函数进行说明: g = imadjust(f, [ low_in hight_in] , [ low_out high_out ] , gamma ); 该函数将 f 中的灰度值映射为g中的新值,即将[ low_in ...

空空如也

空空如也

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

灰度拉伸公式