精华内容
下载资源
问答
  • 图像灰度拉伸

    2012-12-05 10:54:10
    灰度拉伸,C# 代码和运行,有相机拍照,打开图像,保存图像等功能,其中图像的灰度直方图是自写控件
  • 【图像处理】-004 图像灰度拉伸

    千次阅读 2018-12-11 13:58:45
    图像灰度拉伸 文章目录1 原理2 Matlab实现3 OpenCV实现4 效果 1 原理   图像灰度拉伸是改变图像对比度的一种方法,通过灰度映射,将原图中某一区段中的灰度值映射到另一灰度值,从而拉伸或压缩整个图像的灰度...

    图像灰度拉伸

    1 原理

      图像灰度拉伸是改变图像对比度的一种方法,通过灰度映射,将原图中某一区段中的灰度值映射到另一灰度值,从而拉伸或压缩整个图像的灰度分布范围。

    2 Matlab实现

    clc;
    clear;
    close all;
    
    % 对灰度图进行灰度线性变换
    ori_img = imread('../images/6.jpg');
    ori_img1 = rgb2gray(ori_img);
    [oriHist,oriX] = imhist(ori_img1);
    
    pt0 = [0,0];
    pt1 = [100,50];
    pt2 = [150,160];
    pt3 = [255,200];
    
    [width,height] = size( ori_img1);
    gray1 = ori_img1;
    for i=1:1:width
        for j = 1:1:height
            if (gray1(i,j)<pt1(1))
                gray1(i,j) = pt0(2) + (gray1(i,j)-pt0(1)) * ((pt1(2)-pt0(2))/(pt1(1)-pt0(1)));
            else if(gray1(i,j)>=pt1(1)&&gray1(i,j)<pt2(1))
                    gray1(i,j) = pt1(2) + (gray1(i,j)-pt1(1)) * ((pt2(2)-pt1(2))/(pt2(1)-pt1(1)));
                else
                    gray1(i,j) = pt2(2) + (gray1(i,j)-pt2(1)) * ((pt3(2)-pt2(2))/(pt3(1)-pt2(1)));
                end
            end
        end
    end
    [g1Hist,g1X] = imhist(gray1);
    figure(1),subplot(1,2,1),imshow(ori_img1),title('原图');subplot(1,2,2),imshow(gray1),title('灰度线性拉伸');
    figure(2),subplot(1,2,1),stem(oriX,oriHist),title('原图直方图');subplot(1,2,2),stem(g1X,g1Hist),title('灰度线性拉伸直方图');
    
    

    3 OpenCV实现

    //
    int cvPointCmp(cv::Point& a, cv::Point& b)
    {
    	return a.x < b.x;
    }
    
    //根据控制点,生成灰度拉伸所使用的查找表
    void CreateLSLUT(std::vector<cv::Point>& pts, cv::Mat& lut)
    {
    	if (pts.size() == 0)
    		return;
    	//在控制点前增加(0,0)点,末尾增加(255,255)点
    	std::vector<cv::Point> npts(1, cv::Point(0, 0));
    	npts.insert(npts.end(), pts.begin(), pts.end());
    	npts.push_back(cv::Point(255, 255));
        //根据点的X坐标排序
    	std::sort(npts.begin(), npts.end(), cvPointCmp);
    
    	lut = cv::Mat(1, 256, CV_8UC1);
    	int nLoc = 0;
    	for (int i = 0; i < 256; i++)
    	{
    		for (int j = nLoc; j < npts.size()-1; j++)
    		{
                //找出i所对应的区间的端点,左闭右开区间
    			if (npts[j].x <= i && npts[j+1].x > i)
    			{
    				nLoc = j;
    				float y = npts[j].y + 1.0*(npts[j + 1].y - npts[j].y) / (npts[j + 1].x - npts[j].x)*(i - npts[j].x);
    				if (y < 0)
    					y = 0;
    				if (y > 255)
    					y = 255;
    				lut.at<uchar>(i) = (uchar)y;
    				break;
    			}
    		}
    	}
    }
    
    
    #include "../include/baseOps.h"
    #include <iostream>
    #include <string>
    #include "../include/opencv400/opencv2/opencv.hpp"
    #include "windows.h"
    
    
    int main()
    {
    	SetCurrentDirectoryToExePath();
    
    	cv::Mat ori_img = cv::imread("../images/6.jpg");
    	cv::Mat gray_img;
    	cv::cvtColor(ori_img, gray_img, cv::COLOR_BGR2GRAY);
    	cv::namedWindow("灰度图");
    	cv::imshow("灰度图", gray_img);
    
    	cv::Mat grayHist;
    	calcHist1D(gray_img, grayHist);
    	cv::imshow("hist", grayHist);
    
        //确定控制点
    	std::vector<cv::Point> pts;
    	pts.push_back(cv::Point(50, 100));
    	pts.push_back(cv::Point(100, 80));
    	pts.push_back(cv::Point(80, 120));
    	pts.push_back(cv::Point(250, 80));
    	
        //生成灰度映射表
        cv::Mat lut;
    	CreateLSLUT(pts, lut);
    	
        //查表操作
    	cv::Mat res;
    	cv::LUT(gray_img, lut, res);
    
    	cv::Mat g1Hist;
    	calcHist1D(res, g1Hist);
    	cv::imshow("g1", res);
    	cv::imshow("g1Hist", g1Hist);
    
    
    	cv::waitKey();
    	return 0;
    }
    

    4 效果

    在这里插入图片描述在这里插入图片描述

    展开全文
  • dm642下的视频图像处理,进行灰度拉伸
  • 图像灰度拉神,主要是将图像的灰度拉伸至全灰度区间,计算公式如下: 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,循环方式特别慢。

    展开全文
  • clc;clear all; N=imread('图片1.png'); r1=0; r2=75; s1=0; s2=255; k=(s2-s1)/(r2-r1); b=s1-k*r1; [r,c]=size(N); N1=im2double(N); for x=1:r for y=1:c tmp=N1(x,y);...title('对比度拉伸图像');

    clc;clear all; 

    N=imread('图片1.png');
    r1=0;
    r2=75;
    s1=0;
    s2=255;
    k=(s2-s1)/(r2-r1);
    b=s1-k*r1;


    [r,c]=size(N);
    N1=im2double(N);

    for x=1:r
    for y=1:c
    tmp=N1(x,y);
    if tmp>=r1 && tmp<=r2
    N1(x,y)=k*tmp+b;
    end
    end
    end
    subplot(1,2,1);imshow(N);title('原图像');
    subplot(1,2,2);imshow(N1);title('对比度拉伸后图像');

    展开全文
  • %p = imread('F:/personal/2_硕士/1_2_研一下学期/3_图像处理技术... %rgb2gray()函数能将彩色图像转换成灰度图像。 %p = rgb2gray(p); %figure, imshow(p); %figure, imhist(p);%读取灰度图像灰度值。 %imread...

    %p = imread('F:/personal/2_硕士/1_2_研一下学期/3_图像处理技术(李智)/2017.03.15/0_picturelong1/lena512.bmp'); %rgb2gray()函数能将彩色图像转换成灰度图像。 %p = rgb2gray(p);  %figure, imshow(p); %figure, imhist(p);

    %读取灰度图像的灰度值。 %imread函数用于读入各种图像文件,其一般的用法为 %[X,MAP]=imread('filename', 'fmt') %其中,X,MAP分别为读出的图像数据和颜色表数据,fmt为图像的格式, %filename为读取的图像文件(可以加上文件的路径)。 %例:[X, MAP] = imread('flowers.tif', 'tif'); %比较读取二值图像,灰度图像,索引图像,彩色图像的X和MAP的特点, %可以利用size函数用来显示数组的维数,了解数据的特点。 %B=size(a) 返回数组a的维数。 %[X, MAP] = imread('F:/personal/2_硕士/1_2_研一下学期/3_图像处理技术(李智)/2017.03.15/0_picturelong1/lena512.bmp', 'bmp'); %original = X;

    %线性对比度拉伸。 %LinearTransformFunc(original);

    %指数对比度拉伸。 %IndexTransformFunc(original);

    %对数对比度拉伸。 %LogarithmTransformFunc(original);

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

    千次阅读 2018-04-19 17:13:00
    灰度拉伸 定义:灰度拉伸,也称对比度拉伸,是一种简单的线性点运算。作用:扩展图像的 直方图,使其充满整个灰度等级范围内 公式: g(x,y) = 255 / (B - A) * [f(x,y) - A], 其中,A = min[f(x,y)],最...
  • 基于C语言的医学图像处理的设计目 录摘 要1关键词1Abstract2Key wards2前言31 绪论41.1 图像与数字图像处理41.1.1 图像的定义41.1.2 人类的视觉41.1.3 图像的数字化处理41.2 数字图像处理工作本身的特点41.3 数字...
  • //定义图像灰度拉伸函数 private static Bitmap GrayLP (Bitmap a) { Rectangle rect = new Rectangle(0, 0, a.Width, a.Height); System.Drawing.Imaging.BitmapData srcData = a.LockBits(rect, System.Drawing....
  • 图像处理灰度拉伸

    2013-09-12 18:56:55
    基于MFC的程序开发,利用图像处理中的灰度拉伸来编辑代码
  • 这个函数提供灰度拉伸功能,输入图像应当是灰度图像,但如果提供的不是灰度 图像的话,函数会自动将图像转化为灰度形式。x1,x2,y1,y2应当使用双精度 类型存储,图像矩阵可以使用任何MATLAB支持的类型存储。
  • 数字图像灰度拉伸

    2021-02-14 10:37:40
    通过灰度拉伸可加大图像的对比度,使图像变得更加清晰。 灰度拉伸分为线性拉伸和非线性拉伸两种方法。 1、线性拉伸对像素值进行线性比例变化,主要有以下几种方法: 全域线性拉伸 2%线性拉伸 分段线性拉伸 ...
  • 图像灰度拉伸、直方图均衡化处理、GUI界面 matlab图像处理学生作业
  • 图像增强—灰度拉伸

    千次阅读 2016-01-11 14:05:03
    灰度拉伸是一种图像增强算法,属于线性点运算的一种。灰度拉伸。也称对比度拉伸,是一种简单的线性点运算。它扩展图像的直方图,使其充满整个灰度级范围内。 设f(x,y)为输入图像,它的最小灰度级A和最大灰度级B的...
  • 开发环境为QT5.8+opencv3.2,主要实现了图像点运算,包括图像反色,灰度拉伸,灰度均衡。
  • 精通系列\精通Visual C++数字图像处理技术与工程案例\chap01\灰度拉伸.rar
  • VC图像处理中 灰度拉伸的源程序和图片,源程序有注解。
  • 图像进行灰度拉伸及均衡化
  • 输出给定图像的直方图,给定线性变换函数实现图像灰度拉伸,实现图像的均衡化
  • 直方图均衡、灰度拉伸、灰度线性变换的Java实现
  • 点运算VS2017编译通过,可直接运行 包括 图像反色 线性变换 阈值变换 窗口变换 灰度拉伸 灰度均衡
  • 图像灰度拉伸算法的FPGA实现.pdf
  • 为了调整图像数据灰度,介绍了一种图像灰度拉伸算法的FPGA实现方法,并针 对FPGA的特点对算法的实现方法进行了研究,从而解决了其在导引系统应用中的实时性问题。 仿真验证结果表明:基于FPGA的图像拉伸算法具有...
  • 灰度拉伸算法

    2017-11-27 17:07:35
    该算法主要是在图像处理过程中对图像灰度进行拉伸处理。
  • [图像增强]四 灰度拉伸

    万次阅读 2013-08-12 13:44:45
    灰度拉伸可以更加灵活的控制输出灰度直方图的分布,它可以有选择的拉伸某段灰度区间以改善输出图像。 如上图,所示的变换函数的运算结果是将原图在A.x对应灰度转换成A.y对应灰度. 同理B也是. 上图X, Y...

空空如也

空空如也

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

图像灰度拉伸