图像处理线性拉伸_图像 线性拉伸 - CSDN
  • 实验内容及实验原理:1、灰度的线性变换灰度的线性变换就是将图像中所有的点的灰度按照线性灰度变换函数进行变换。该线性灰度变换函数是一个一维线性函数:f(x)=a*x+b其中参数a为线性函数的斜率,b为线性函数的在y轴...

    实验内容及实验原理:

    1、灰度的线性变换

    灰度的线性变换就是将图像中所有的点的灰度按照线性灰度变换函数进行变换。该线性灰度变换函数是一个一维线性函数:f(x)=a*x+b

    其中参数a为线性函数的斜率,b为线性函数的在y轴的截距,x表示输入图像的灰度,f(x)表示输出图像的灰度。

    要求:输入一幅图像,根据输入的斜率和截距进行线性变换,并显示。

    2、灰度拉伸

    灰度拉伸和灰度线性变换相似。不同之处在于它是分段线性变换。表达式如下:


    其中,x1和x2是分段函数的转折点。

    要求:输入一幅图像,根据选择的转折点,进行灰度拉伸,显示变换后的图像。

    3、灰度直方图

    灰度直方图是灰度值的函数,描述的是图像中具有该灰度值的像素的个数,其横坐标表示像素的灰度级别,纵坐标表示该灰度出现的频率(象素的个数)。

    要求:输入一幅图像,显示它的灰度直方图,可以根据输入的参数(上限、下限)显示特定范围的灰度直方图。

    4、直方图均衡:要求

    1)    显示一幅图像pout.bmp的直方图;

    2)    用直方图均衡对图像pout.bmp进行增强;

    3)    显示增强后的图像。

    实验过程:

    打开原图像,创建结果图像:

    IplImage *src = cvLoadImage("pout.bmp", 1);//原图
    IplImage *dst =cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 1);

    函数说明:

    CVAPI(IplImage*)cvLoadImage( constchar* filename, intiscolorCV_DEFAULT (CV_LOAD_IMAGE_COLOR));
    
    //Iscolor的值:
    enum{
    /* 8bit, color ornot */  CV_LOAD_IMAGE_UNCHANGED  =-1,
    /* 8bit, gray */         CV_LOAD_IMAGE_GRAYSCALE  =0,
    /* ?, color */           CV_LOAD_IMAGE_COLOR      =1,
    /* any depth, ? */       CV_LOAD_IMAGE_ANYDEPTH   =2,
    /* ?, any color */       CV_LOAD_IMAGE_ANYCOLOR   =4,
    /* ?, no rotate */       CV_LOAD_IMAGE_IGNORE_ORIENTATION  =128
    };
    
    CVAPI(IplImage*)  cvCreateImage( CvSizesize, intdepth, intchannels );
    @param size Imagewidth and height
    @param depth Bitdepth of image elements. See IplImage for valid depths.
    @param channelsNumber of channels per pixel. See IplImage for details. This function onlycreates
    images withinterleaved channels.

    图像显示:

    cvNamedWindow("Image", 1);//创建窗口
    cvShowImage("Image", dst);//显示图像,在指定窗口显示制定图像
    cvWaitKey(0); //等待按键
    cvDestroyWindow("Image");//销毁窗口
    
    //函数说明
    CVAPI(int)cvNamedWindow( constchar* name, intflagsCV_DEFAULT(CV_WINDOW_AUTOSIZE) );
    Flags:
    CV_WINDOW_NORMAL   =0x00000000, //the user canresize the window (no constraint)  / alsouse to switch a fullscreen window to a normal size
    CV_WINDOW_AUTOSIZE = 0x00000001, //the user cannot resize the window, the size isconstrainted by the image displayed
    CV_WINDOW_OPENGL   =0x00001000, //window with openglsupport

    灰度线性变换

    对图像的每个像素遍历,获取原图像的灰度值,然后计算线性变换后的值,设置目标图像相应位置的灰度值

    for (int i = 0;i < src->height; i++){
         for (int j = 0; j < src->width; j++){
             CvScalar s =cvGet2D(src, i, j);
             s.val[0] = fa * s.val[0] + fb;
             cvSet2D(dst, i, j, s);
         }
    }
    
    //函数说明:
    //参数为图像指针和坐标,如果指定位置不存在则返回0
    CVAPI(CvScalar)cvGet2D( constCvArr* arr, intidx0, intidx1 );
    The functions returna specific array element. In the case of a sparse array the functions return 0
    if the requestednode does not exist (no new node is created by the functions).
    @param arr Inputarray
    @param idx0 Thefirst zero-based component of the element index
    //返回值类型:
    typedefstructCvScalar{
    double val[4];
    }

    变换前:

    变换后:

    灰度拉伸

    根据当前灰度值所处的区间进行相应的变换

    for (int i = 0;i < src->height; i++){
         for (int j = 0; j < src->width; j++){
             CvScalar s =cvGet2D(src, i, j);
             if(s.val[0] < x1)
                  s.val[0] = y1 / x1*s.val[0];
             elseif (s.val[0] <= x2)
                  s.val[0] = (y2 - y1) / (x2 -x1)*(s.val[0] - x1) + y1;
             else
                  s.val[0] = (255 - y2) / (255 -x2)*(s.val[0] - x2) + y2;
             cvSet2D(dst, i, j, s);
         }
    }

    变换前:

    变换后:

    灰度直方图

    将灰度分为256个离散的值进行统计,存放在table数组中

    for (int i = 0;i < src->height; i++){
         for (int j = 0; j < src->width; j++){
             CvScalar s =cvGet2D(src, i, j);
             table[(int)s.val[0]]++;
         }
    }
    
    //找出灰度出现次数的最大值,以对直方图进行缩放
    for (int i = 0;i < 256; i++)
         if (table[i]> max)max = table[i];
    
    //创建直方图:
    Mat histgram(256, 256, CV_8U, Scalar(255));
    
    //构造函数说明:
    /** @overload
    @param rows Numberof rows in a 2D array.
    @param cols Numberof columns in a 2D array.
    @param type Arraytype. Use CV_8UC1...CV_64FC4 to create 1-4 channel matrices, orCV_8UC(n)...CV_64FC(n) to create multi-channel (up toCV_CN_MAX channels) matrices.
    @param s An optionalvalue to initialize each matrix element with. To set all the matrix elements tothe particular value after the construction, use theassignment operator
    Mat::operator=(constScalar& value) .
    */
    Mat(introws, intcols, inttype, constScalar& s);//s是所有像素的初始化值
    
    //绘制直方图:在指定的范围内画线,线的长度为指定会的像素个数,并且缩放到255之间
    for (int i =range[0]; i <= range[1]; i++)
         line(histgram, Point(i,255), Point(i, (255 - table[i]*255/max)), Scalar(0));

    直方图:


    直方图均衡

    计算累计直方图并取整确定映射关系:

    for (int i = 1;i < 256; i++){
         s_table[i%2] = s_table[(i - 1)%2] + (float)table[i] / sum;
         new_table[i] = (int)(s_table[i%2]* 255 + 0.5);
    }

    用新值绘制新图

    均衡前:

    均衡后:

    源码:

    // opencv1.cpp: 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include<iostream>  
    #include <opencv2/core/core.hpp>  
    #include <opencv2/highgui/highgui.hpp>  
    #include <cv.h>
    //#include <highgui.h>
    #include <cxcore.h>
    #include <cvaux.h>
    #include <stdlib.h>
    #include <imgproc.hpp>
    
    using namespace cv;
    
    int main()
    {
    	IplImage *src;
    	src = cvLoadImage("pout.bmp", 1);//原图
    	IplImage *dst = cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 1);
    	
    	
    	std::cout << "灰度线性变换..."<<std::endl;
    	double fa = 1.0, fb = 0.0;
    	while (fa >= 0)
    	{
    		for (int i = 0; i < src->height; i++)
    		{
    			for (int j = 0; j < src->width; j++)
    			{
    				CvScalar s = cvGet2D(src, i, j);
    				s.val[0] = fa * s.val[0] + fb;
    				cvSet2D(dst, i, j, s);
    			}
    		}
    		cvNamedWindow("Image", 1);//创建窗口
    		cvShowImage("Image", dst);//显示图像
    		cvWaitKey(0); //等待按键
    		cvDestroyWindow("Image");//销毁窗口
    
    		std::cin >> fa >> fb; 
    	}
    
    	std::cout << "灰度拉伸..."<<std::endl;
    	double x1 = 0.0, y1 = 0.0, x2 = 1.0, y2 = 1.0;
    	while (x1 >= 0)
    	{
    		for (int i = 0; i < src->height; i++)
    		{
    			for (int j = 0; j < src->width; j++)
    			{
    				CvScalar s = cvGet2D(src, i, j);
    				if (s.val[0] < x1)
    				{
    					s.val[0] = y1 / x1*s.val[0];
    				}
    				else if (s.val[0] <= x2)
    				{
    					s.val[0] = (y2 - y1) / (x2 - x1)*(s.val[0] - x1) + y1;
    				}
    				else
    				{
    					s.val[0] = (255 - y2) / (255 - x2)*(s.val[0] - x2) + y2;
    				}
    				cvSet2D(dst, i, j, s);
    			}
    		}
    		cvNamedWindow("Image", 1);//创建窗口
    		cvShowImage("Image", dst);//显示图像
    		cvWaitKey(0); //等待按键
    		cvDestroyWindow("Image");//销毁窗口
    
    		std::cin >> x1 >> y1 >> x2 >> y2;
    	}
    	
    
    	std::cout << "灰度直方图..." << std::endl;
    
    	int table[256] = { 0 };
    	int range[] = { 0, 255 };
    	std::cin >> range[0] >> range[1];
    	for (int i = 0; i < src->height; i++)
    	{
    		for (int j = 0; j < src->width; j++)
    		{
    			CvScalar s = cvGet2D(src, i, j);
    			table[(int)s.val[0]]++;
    		}
    	}
    	double max = 0;
    	int sum = 0;
    	for (int i = 0; i < 256; i++)
    	{
    		sum += table[i];
    		if (table[i] > max)max = table[i];
    		//std::cout << table[i] << std:: endl;
    	}
    	Mat histgram(256, 256, CV_8U, Scalar(255));
    	for (int i = range[0]; i <= range[1]; i++)
    	{
    		line(histgram, Point(i, 255), Point(i, (255 - table[i]*255/max)), Scalar(0));
    	}
    	namedWindow("histgram");
    	imshow("histgram", histgram);
    	waitKey(0);
    
    
    	std::cout << "灰度均衡直方图..." << std::endl;
    	int new_table[256] = { 0 };
    	float s_table[2] = { (float)table[0]/sum };
    	for (int i = 1; i < 256; i++)
    	{
    		s_table[i%2] = s_table[(i - 1)%2] + (float)table[i] / sum;
    		new_table[i] = (int)(s_table[i%2] * 255 + 0.5);
    	}
    	for (int i = 0; i < src->height; i++)
    	{
    		for (int j = 0; j < src->width; j++)
    		{
    			CvScalar s = cvGet2D(src, i, j);
    			s.val[0] =new_table[(int)s.val[0]];
    			cvSet2D(dst, i, j, s);
    		}
    	}
    
    
    	cvNamedWindow("Image", 1);//创建窗口
    	cvShowImage("Image", dst);//显示图像
    	cvWaitKey(0); //等待按键
    	cvDestroyWindow("Image");//销毁窗口
    
    
    	cvReleaseImage(&dst); //释放图像
    }
    
    

    原图:(原来是bmp格式的,但是不能上传,改成png格式了,分辨率都是256X256的)



    展开全文
  • 图像处理-线性拉伸

    千次阅读 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)直接线性拉伸


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


    展开全文
  • 用C语言写的图像处理程序,包括读入8位图像,对图像进行直方图均衡化,灰度线性变化和灰度线性拉伸
  • 对比拉伸也就是灰度拉伸,主要是通过改善图像灰度级的动态范围,來改善的图像品质。 如下图:将原灰度集中拉升到均匀提升图像品质。 ... 三段线性拉伸的公式:假定要将原图 r1 - r2 的区域...

    对比拉伸也就是灰度拉伸,主要是通过改善图像灰度级的动态范围,來改善的图像品质。

    如下图:将原灰度集中拉升到均匀提升图像品质。

     

    对比拉伸的本质是使用分段函数进行的线性变换,如下图:输出图像通过牺牲 0 ~ r1 和 r2 ~ L-1 的灰度级,来使s1 ~ s2的灰度级动态范围增加,达到改善图像此区域的的品质。  

    • 三段线性拉伸的公式:假定要将原图 r1 - r2 的区域拉伸至 s1 - s2 区域。令oldl为原图灰度级,newl为新灰度级。

      • oldl < r1 :  newl = oldl / r1 * s1 ;

      • r1 < oldl < r2 : newl = (oldl - r1) / (r2 - r1) * (s2 - s1) + s1 ;

      • oldl > r2 :newl = (oldl - r2) / (255 - r2) * (255 - s2) + s2 ;

    C#实现:

    //灰阶对比拉伸
            public Bitmap contrastStreching(Bitmap grayImage, double r1, double r2, double s1, double s2)
            {
                //用LockBits的方法,效果一致。
                //BitmapData grayImageData = grayImage.LockBits(new Rectangle(0, 0, grayImage.Width, grayImage.Height), ImageLockMode.ReadWrite, grayImage.PixelFormat);
                //IntPtr intPtr = grayImageData.Scan0;
                //int byteSize = grayImageData.Stride * grayImageData.Height;
                //byte[] originalBytes = new byte[byteSize];
                //Marshal.Copy(intPtr, originalBytes, 0, byteSize);
    
                //double y;
                //for (int i = 0; i < originalBytes.Length; i++)
                //{
                //    byte x = originalBytes[i];
                //    if (x < r1)
                //    {
                //        y = (x / r1) * s1;
                //    }
                //    else if (x <= r2)
                //    {
                //        y = ((x - r1) / (r2 - r1)) * (s2 - s1) + s1;
                //    }
                //    else
                //    {
                //        y = ((x - r2) / (255 - r2)) * (255 - s2) + s2;
                //    }
                //    originalBytes[i] = (byte)Math.Round(y);
                //}
                //Marshal.Copy(originalBytes, 0, intPtr, byteSize);
                //grayImage.UnlockBits(grayImageData);
    
                for (int j = 0; j < grayImage.Height; j++)
                {
                    for (int i = 0; i < grayImage.Width; i++)
                    {
                        double y = 0;
                        byte value = grayImage.GetPixel(i, j).R;
                        if (value < r1)
                        {
                            y = (value / r1) * s1;
                        }
                        else if (value <= r2)
                        {
                            y = ((value - r1) / (r2 - r1)) * (s2 - s1) + s1;
                        }
                        else
                        {
                            y = ((value - r2) / (255 - r2)) * (255 - s2) + s2;
                        }
                        byte s = (byte)Math.Round(y);
                        Color newValue = Color.FromArgb(s, s, s);
                        grayImage.SetPixel(i, j, newValue);
                    }
                }
    
                return grayImage;
            }

     

    仅为个人理解,如有不足,请指教。 https://blog.csdn.net/weixin_35811044

    展开全文
  • 参考链接:http://www.voidcn.com/article/p-ethxsjor-du.html

    遥感图像数据大多为16位,在显示时要将其拉伸到0-255的区间范围,ENVI软件打开图像时默认使用2%的线性拉伸,思路是将直方图累积在2%和98%之间的像元值拉伸,取直方图累积在2%处对应的光谱值为MinValue,98%处对应的光谱值为MaxValue,那么可解释为如果像元值大于MinValue且小于MaxValue,则将其拉伸至0-255;如果像元值小于MinValue,那么将其改为MinValue;如果像元值大于MaxValue,那么将其改为255。

    下面给出一个对直方图进行2%线性拉伸的例子

    利用GDAL可以使用函数poBand->GetHistogram来得到波段的直方图,然后对直方图进行计算进行线性拉伸,并不复杂。

    下面给出2%线性拉伸的Matlab代码供参考

    cal_lr_val.m文件,对于输入的直方图,计算拉伸时应取的左值和右值

    % ------------------------------------
    % 计算直方图左右裁剪的灰度值
    % 2015/07/01
    %
    % Input histcount --> 直方图
    % tt --> 图像像素个数
    % per --> 左右裁剪的百分比
    % 
    % Output l_val --> 左值
    % r_val --> 右值
    % ------------------------------------
    
    function [l_val, r_val] = calc_lr_val(histcount, tt, per)
    
        fprintf(' ... ... ... ... ... ... ... ... ...\n');
        fprintf(' ... CALC LEFT AND RIGHT VALUE \n');
    
        per_tt = tt*per;  % 按百分比裁剪的像素个数 
    
        % 计算左值
        tmp = 0;
        for i = 1:length(histcount)
            tmp = tmp + histcount(i);
            if tmp >= per_tt
                l_val = i;
                break;
            end
        end
        % 计算右值
        tmp = 0;
        for i = 1:length(histcount)
            tmp = tmp + histcount(length(histcount)-i+1);
            if tmp >= per_tt
                r_val = length(histcount)-i+1;
                break;
            end
        end
    
        fprintf(' ... Stretch Percentage is %d%%\n', per*100);
        fprintf(' ... Left Val is %d \n', l_val);
        fprintf(' ... Right Val is %d \n', r_val);
        fprintf(' ... ... ... ... ... ... ... ... ...\n\n');
    
    return

    img_map.m文件,根据计算的左值和右值,将16位图像拉伸,输出为8位图像

    % ------------------------------------
    % 将图像映射至 [0, 255] 区间
    % 2015/07/01
    %
    % Input img_16bit --> 16位原图像
    % l_val --> 映射左值
    % r_val --> 映射右值
    % 
    % Output img_8bit --> 输出8位拉伸后图像
    % ------------------------------------
    
    function [img_8bit] = img_map(img_16bit, l_val, r_val)
    
        [xlen, ylen, c] = size(img_16bit);
        img_8bit = zeros(xlen, ylen);
    
        fprintf(' ... ... ... ... ... ... ... ... ...\n');
        fprintf(' ... IMG MAPPING FROM 16BIT TO 8BIT \n');    
        fprintf(' ... Img mapping begin ... ... \n');
    
        % 按照左右值映射
        img_8bit = (img_16bit - l_val).*(255/(r_val-l_val));
        img_8bit = uint8(round(img_8bit));
    
    
        fprintf(' ... Img mapping finshied !!! !!! \n\n');
    
    return

    main.m 程序的主文件

    fprintf(' ... Read Imagery ... ...\n');
    img = imread('./Img/test_pic_1.tif');
    
    % 这里默认输入图像为单通道
    [ylen, xlen] = size(img);
    fprintf(' ... Img Xlen: %d pixels\n', xlen);
    fprintf(' ... Img Ylen: %d pixels\n\n\n', ylen);
    
    % 线性拉伸
    max_val = max(img(:));
    min_val = min(img(:));
    fprintf(' ... ... ... ... ... ... ... ... ... ...\n');
    fprintf(' ... Min Val is %d \n', min_val);
    fprintf(' ... Max Val is %d \n', max_val);
    fprintf(' ... ... ... ... ... ... ... ... ... ...\n\n');
    
    % 统计直方图
    % 输入图像为16位,取值范围为 0 到 65535
    bins = 0:65535;
    histcount = histc(img(:)', bins); 
    %清除临时变量 
    clear bins max_val min_val; 
    % 直方图裁剪,计算左值和右值 
    [l_val, r_val] = calc_lr_val(histcount, xlen*ylen, 0.02); 
    % 根据左值和右值,将图像由16位映射至8位 
    img_8bit = img_map(img, l_val, r_val); 
    % 保存结果 
    imwrite(img_8bit, 'res.png');
    
    return

     

    参考链接:http://www.voidcn.com/article/p-ethxsjor-du.html

    展开全文
  • (2), 求斜率,即斜率大于1,则拉伸;(3), 根据线性公式,求拉伸后灰度值,如下图1. matlab代码:%题目: 对比...%已知条件:原图像的目标景物灰度范围[fa,fb],拉伸后范围在[ga,gb]。 %实现方法:目标景物灰度范...
  • 1、
  • 题目:定义一个图像的对比度拉伸函数,函数名为myGrayScaleTransform,将输入图像的对比度线性平滑地拉伸到指定的灰度级区间,要求该函数的输入参数包括处理前的灰度图像img1 (如EXP1A.tif)、期望灰度级的参数区间...
  • 上一篇文章介绍了百分比截断拉伸,本篇介绍标准差拉伸,线性拉伸的思想还是不变,寻找极值范围,极值范围的值直接映射到目标像素极值上,其他值仍旧线性拉伸。 标准差拉伸寻找的极值有一个参数,那就是标准差倍数,...
  • 数字图像处理

    2020-05-11 13:33:43
    数字图像处理 图像灰度的线性拉伸 图像灰度的拉伸,指的是通过线性点运算的灰度变换函数,用线性方程改变输出图像的灰度。 线性方程为s=ar+b (s输出图像灰度,r输入图像灰度,灰度越大越亮) 可以通过改变a和b的值...
  • 图像拉伸

    千次阅读 2019-06-02 15:54:33
    图像拉伸是最基础的图像处理方法,主要用来改善图像显示的对比度,道路提取流程中往往首先要对图像进行拉伸的预处理。图像拉伸主要有三种方式:灰度拉伸、直方图均衡化和直方图规定化。下面主要看看灰度拉伸: 灰度...
  • 前些天本来打算用VC6.0 + opencv1.0去学习图像处理,但后来发现还是VS + opencv2以上版本做比较顺手,所以装了vs2015,配置了环境什么的(VS2015配置opencv3.1.0)。在把环境配置好后,我就上网学习了别人写的代码,...
  • python2%线性拉伸

    2020-05-01 21:42:25
    python实现2%的线性拉伸
  • 数字图像处理实验之对比度拉伸

    千次阅读 2019-07-17 15:38:42
    书本中(冈萨雷斯:数字图像处理第三版P69)的对比度拉伸变换函数图是这样的: 图3.10(b)低对比度拉伸图中,最低灰度级为91,最高灰度级为138,并且要将灰度值拉伸至[0, 255]。阈值处理的函数的图像即为P64图3.2...
  • matlab 实现图像 灰度分段线性处理 具有交互界面,可直接运行
  • 人类所获得的信息大约70%来自于图像,数字图像处理是计算机对采样量化的图像进行去除噪声、增强、复原、分割、提前特征等处理的方法和技术,它对一个物体的数字表示施加一系列的操作,以得到所期望的结果。...
  • 利用分段线性函数来增强图像对比度的方法实际上增强原图各部分的反差,即增加图像中感兴趣的灰度区域,相对抑制那些不感兴趣的灰度区域。 分段的灰度拉伸可以更加灵活的控制输出灰度直方图的分布,可以有选择性的...
  • 图像灰度线性变换 假定原图像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...
  • 本篇博客旨在将自己对遥感数字图像显示和拉伸的初步理解记录下来...... 照片和遥感数字图像 遥感数字图像的表示和统计描述 图像显示和拉伸 ———————————————————————————————— ...
  • 我们前面提到过图像二值化,图像反转,本质上是对图像的所有像素点的灰度进行操作,属于灰度变换的内容。灰度变换的主要目的是用于图像增强。 而对比度拉伸图像增强的一种方法,也属于灰度变换操作。我们看如下...
1 2 3 4 5 ... 20
收藏数 5,823
精华内容 2,329
关键字:

图像处理线性拉伸