精华内容
下载资源
问答
  • 大津法

    2017-03-13 22:29:00
    大津法理解 ...大津法(OTSU)是一种确定图像二值化分割阈值的...从大津法的原理上来讲,该方法又称作最大类间方差法,因为按照大津法求得的阈值进行图像二值化分割后,前景与背景图像的类间方差最大(何为...

    转自http://blog.163.com/yuyang_tech/blog/static/216050083201302113341762/

    大津法理解  

    大津法(OTSU)是一种确定图像二值化分割阈值的算法,由日本学者大津于1979年提出。从大津法的原理上来讲,该方法又称作最大类间方差法,因为按照大津法求得的阈值进行图像二值化分割后,前景与背景图像的类间方差最大(何为类间方差?原理中有介绍)。

    原理:

    对于图像I(x,y),前景(即目标)和背景的分割阈值记作T,属于前景的像素点数占整幅图像的比例记为ω0,其平均灰度μ0;背景像素点数占整幅图像的比例为ω1,其平均灰度为μ1。图像的总平均灰度记为μ,类间方差记为g。

    假设图像的背景较暗,并且图像的大小为M×N,图像中像素的灰度值小于阈值T的像素个数记作N0,像素灰度大于阈值T的像素个数记作N1,则有:
          ω0=N0/ M×N (1)
          ω1=N1/ M×N (2)
          N0+N1=M×N (3)
          ω0+ω1=1    (4)
          μ=ω0*μ0+ω1*μ1 (5)
          g=ω0(μ0-μ)^2+ω1(μ1-μ)^2 (6)
    将式(5)代入式(6),得到等价公式:
          g=ω0ω1(μ0-μ1)^2    (7) 这就是类间方差
    采用遍历的方法得到使类间方差g最大的阈值T,即为所求。

    转载于:https://www.cnblogs.com/fdd566/p/6545437.html

    展开全文
  • Ostu大津法1004

    2019-01-10 22:55:38
    Ostu大津法阈值判别,使用matlab,较简单,可以借鉴
  • 大津法ostu

    2013-11-22 15:23:43
    大津法,最大类间方差法,opencv中二值化
  • 大津法动态阈值.docx

    2020-04-16 22:15:11
    大津法动态阈值可实现1.4ms 刷新一次,相对于普通的大津法动态阈值性能上有一定程度的提升,大大减小处理时间。
  • OTSU算法(大津法—最大类间方差法)原理及实现

    万次阅读 多人点赞 2019-05-13 22:26:12
    大津法的原理上来讲,该方法又称作最大类间方差法,因为按照大津法求得的阈值进行图像二值化分割后,前景与背景图像的类间方差最大。 它被认为是图像分割中阈值选取的最佳算法,计算简单,不受图像亮度和对比度的...

    写在前面

    大津法(OTSU)是一种确定图像二值化分割阈值的算法,由日本学者大津于1979年提出。从大津法的原理上来讲,该方法又称作最大类间方差法,因为按照大津法求得的阈值进行图像二值化分割后,前景与背景图像的类间方差最大。

    它被认为是图像分割中阈值选取的最佳算法,计算简单,不受图像亮度和对比度的影响,因此在数字图像处理上得到了广泛的应用。它是按图像的灰度特性,将图像分成背景和前景两部分。因方差是灰度分布均匀性的一种度量,背景和前景之间的类间方差越大,说明构成图像的两部分的差别越大,当部分前景错分为背景或部分背景错分为前景都会导致两部分差别变小。因此,使类间方差最大的分割意味着错分概率最小。

    应用:是求图像全局阈值的最佳方法,应用不言而喻,适用于大部分需要求图像全局阈值的场合。

    优点:计算简单快速,不受图像亮度和对比度的影响。

    缺点:对图像噪声敏感;只能针对单一目标分割;当目标和背景大小比例悬殊、类间方差函数可能呈现双峰或者多峰,这个时候效果不好。

    Opencv 接口:

    double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)

    Opencv 官方文档:https://docs.opencv.org/3.0-last-rst/modules/imgproc/doc/miscellaneous_transformations.html?highlight=threshold#threshold

    Github: https://github.com/2209520576/Image-Processing-Algorithm 。欢迎Star、Fork。
     

    原理

    原理非常简单,涉及的知识点就是均值、方差等概念和一些公式推导。为了便于理解,我们从目的入手,反推一下这著名的OTSU算法。

    求类间方差:

    OTSU算法的假设是存在阈值TH将图像所有像素分为两类C1(小于TH)和C2(大于TH),则这两类像素各自的均值就为m1、m2,图像全局均值为mG。同时像素被分为C1和C2类的概率分别为p1、p2。因此就有:

                                                                 p1*m1+p2*m2=mG                                           (1)

                                                                       p1+p2=1                                                      (2)

    根据方差的概念,类间方差表达式为:

                                                            \sigma ^{2}=p1(m1-mG)^{2}+p2(m2-mG)^{2}             (3)

    我们把上式化简,将式(1)代入式(3),可得:

                                                              \sigma ^{2}=p1p2(m1-m2)^{2}                                       (4)

    其实求能使得上式最大化的灰度级 k 就是OTSU阈值了,很多博客也是这样做的。

    其中:

                                                                p1=\sum_{i=0}^{k}p_{i}                                                       (5)     

                                                                 m1=1/p1 *\sum_{i=0}^{k}ip_{i}                                        (6)

                                                                 m2=1/p2 *\sum_{i=k+1}^{L-1}ip_{i}                                      (7)

    照着公式,遍历0~255个灰度级,求出使式(4)最大的 k 就ok了。

    -------------------------------------------------------------------------分割线-------------------------------------------------------------------------------------

    但是根据原文(为了尊重原文),式(4)还可以进一步变形。

              首先灰度级K的累加均值m图像全局均值mG分别为:

                                                                  m=\sum_{i=0}^{k}ip_{i}                                                   (8)

                                                                  mG=\sum_{i=0}^{L-1}ip_{i}                                                (9)

                                                                  

    再瞅瞅式(6),m1、m2就可变为:

                                                               m1=1/p1 *m                                              (10)

                                                               m2=1/p2 *(mG-m)                                (11)

     式(10)、(11)代入式(4),我们可得原文最终的类间方差公式:

                                                            \sigma ^{2}=\frac{(mG*p1-m)^{_{2}}}{p1(1-p1)}                                      (12)

    根据公式(5)、(8)、(9)求能使得上式(12)最大化的灰度级 k 就是OTSU阈值。

     

    分割:

    这个分割就是二值化,OpenCV给了以下几种方式,很简单,可以参考:

     

    基于OpenCV实现

    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <opencv2/imgproc.hpp>
    
    int Otsu(cv::Mat& src, cv::Mat& dst, int thresh){
    	const int Grayscale = 256;
    	int graynum[Grayscale] = { 0 };
    	int r = src.rows;
    	int c = src.cols;
    	for (int i = 0; i < r; ++i){
    		const uchar* ptr = src.ptr<uchar>(i);
    		for (int j = 0; j < c; ++j){        //直方图统计
    			graynum[ptr[j]]++;
    		}
    	}
    
        double P[Grayscale] = { 0 };   
    	double PK[Grayscale] = { 0 };
    	double MK[Grayscale] = { 0 };
    	double srcpixnum = r*c, sumtmpPK = 0, sumtmpMK = 0;
    	for (int i = 0; i < Grayscale; ++i){
    		P[i] = graynum[i] / srcpixnum;   //每个灰度级出现的概率
    		PK[i] = sumtmpPK + P[i];         //概率累计和 
    		sumtmpPK = PK[i];
    		MK[i] = sumtmpMK + i*P[i];       //灰度级的累加均值                                                                                                                                                                                                                                                                                                                                                                                                        
    		sumtmpMK = MK[i];
    	}
    	
    	//计算类间方差
    	double Var=0;
    	for (int k = 0; k < Grayscale; ++k){
    		if ((MK[Grayscale-1] * PK[k] - MK[k])*(MK[Grayscale-1] * PK[k] - MK[k]) / (PK[k] * (1 - PK[k])) > Var){
    			Var = (MK[Grayscale-1] * PK[k] - MK[k])*(MK[Grayscale-1] * PK[k] - MK[k]) / (PK[k] * (1 - PK[k]));
    			thresh = k;
    		}
    	}
    
    	//阈值处理
    	src.copyTo(dst);
    	for (int i = 0; i < r; ++i){
    	    uchar* ptr = dst.ptr<uchar>(i);
    		for (int j = 0; j < c; ++j){
    			if (ptr[j]> thresh)
    				ptr[j] = 255;
    			else
    				ptr[j] = 0;
    		}
    	}
    	return thresh;
    }
    
    
    int main(){
    	cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\Fig1039(a)(polymersomes).tif");
    	if (src.empty()){
    		return -1;
    	}
    	if (src.channels() > 1)
    		cv::cvtColor(src, src, CV_RGB2GRAY);
    
    	cv::Mat dst,dst2;
    	int thresh=0;
    	double t2 = (double)cv::getTickCount();
    	thresh=Otsu(src , dst, thresh); //Otsu
    	std::cout << "Mythresh=" << thresh << std::endl;
    	t2 = (double)cv::getTickCount() - t2;
    	double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
    	std::cout << "my_process=" << time2 << " ms. " << std::endl << std::endl;
        double  Otsu = 0;
    
    	Otsu=cv::threshold(src, dst2, Otsu, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
    	std::cout << "OpenCVthresh=" << Otsu << std::endl;
    
    	cv::namedWindow("src", CV_WINDOW_NORMAL);
    	cv::imshow("src", src);
    	cv::namedWindow("dst", CV_WINDOW_NORMAL);
    	cv::imshow("dst", dst);
    	cv::namedWindow("dst2", CV_WINDOW_NORMAL);
    	cv::imshow("dst2", dst2);
    	//cv::imwrite("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Image Filtering\\MeanFilter\\TXT.jpg",dst);
    	cv::waitKey(0);
    }

    效果

    先看看分割效果(和OpenCV自带构造函数对比):效果一样

                                 本文实现                                                      原图                                           opencv自带构造函数

                     

     

    再看看阈值求取的准确性和效率吧(和OpenCV自带构造函数对比):图像分辨率为702 * 648

                                                                               

    求出来的阈值和opencv一样,时间为1ms左右,速度还行。

     

    参考:

    https://www.cnblogs.com/ranjiewen/p/6385564.html

    http://www.dididongdong.com/archives/4614

    展开全文
  • 最大类间方差法(大津法OTSU)

    万次阅读 多人点赞 2016-07-23 16:15:19
    算法介绍最大类间方差法是1979年由日本学者大津提出的,是一种自适应阈值确定的方法,又叫大津法,简称OTSU,是一种基于全局的二值化算法,它是根据图像的灰度特性,将图像分为前景和背景两个部分。当取最佳阈值时,...

    算法介绍

    最大类间方差法是1979年由日本学者大津提出的,是一种自适应阈值确定的方法,又叫大津法,简称OTSU,是一种基于全局的二值化算法,它是根据图像的灰度特性,将图像分为前景和背景两个部分。当取最佳阈值时,两部分之间的差别应该是最大的,在OTSU算法中所采用的衡量差别的标准就是较为常见的最大类间方差。前景和背景之间的类间方差如果越大,就说明构成图像的两个部分之间的差别越大,当部分目标被错分为背景或部分背景被错分为目标,都会导致两部分差别变小,当所取阈值的分割使类间方差最大时就意味着错分概率最小[1]。

    记T为前景与背景的分割阈值,前景点数占图像比例为w0w_0w0,平均灰度为u0u_0u0;背景点数占图像比例为w1w_1w1,平均灰度为u1u_1u1,图像的总平均灰度为uuu,前景和背景图象的方差,则有:
    u=w0×u0+w1×u1u = w_0 \times u_0+w_1 \times u_1u=w0×u0+w1×u1
    g=w0×(u0−u)2+w1×(u1−u)2g = w_0 \times (u_0-u)^2+w_1 \times (u_1-u)^2g=w0×(u0u)2+w1×(u1u)2
    联立上面两式可得:
    g=w0×w1×(u0−u1)2g = w_0 \times w_1 \times (u_0-u_1)^2g=w0×w1×(u0u1)2

    g=w01−w0×(u0−u)2g = \frac{w_0}{1-w_0} \times (u_0-u)^2g=1w0w0×(u0u)2
    当方差ggg最大时,可以认为此时前景和背景差异最大,此时的灰度T是最佳阈值。类间方差法对噪声以及目标大小十分敏感,它仅对类间方差为单峰的图像产生较好的分割效果。当目标与背景的大小比例悬殊时(例如受光照不均、反光或背景复杂等因素影响),类间方差准则函数可能呈现双峰或多峰,此时效果不好。直接用OTSU算法处理自然场景铭牌图片的部分结果实例如下:

    1
    图1.最大类间方差法二值化结果图1.最大类间方差法二值化结果1.

    代码实现

    (C语言版,VS2012+opencv249)
    注意,++和*的结合方式是由右向左,所以histogram[*p++]++ = (histogram[*(p++)])++

    #include "stdio.h"
    #include "cv.h"
    #include "highgui.h"
    #include "Math.h"
    
    int Otsu(IplImage* src);
    
    int main()
    {
    	IplImage* img = cvLoadImage("lena.jpg",0); //获取灰度图像img
    	IplImage* dst = cvCreateImage(cvGetSize(img), 8, 1);
    	int threshold = Otsu(img); //调用大津法求出最佳阈值
    	printf("otsu threshold = %d\n", threshold);
    	cvThreshold(img, dst, threshold, 255, CV_THRESH_BINARY); //用otsu的阈值二值化
    
    	cvNamedWindow( "img", 1 );
    	cvNamedWindow( "dst", 1 );
    	cvShowImage("img", img);
    	cvShowImage("dst", dst);
    
    
    	cvWaitKey(-1);
    
    	cvReleaseImage(&img);
    	cvReleaseImage(&dst);
    	
    	cvDestroyWindow( "img" );
    	cvDestroyWindow( "dst" );
    
    	return 0;
    }
    
    int Otsu(IplImage* src)  
    {  
    	int height=src->height;  
    	int width=src->width;      
    
    	//histogram  
    	float histogram[256] = {0};  
    	for(int i=0; i < height; i++)
    	{  
    		unsigned char* p=(unsigned char*)src->imageData + src->widthStep * i;  
    		for(int j = 0; j < width; j++) 
    		{  
    			histogram[*p++]++;  
    		}  
    	}  
    	
    	//normalize histogram & average pixel value 
    	int size = height * width;  
    	float u =0;
    	for(int i = 0; i < 256; i++)
    	{  
    		histogram[i] = histogram[i] / size;  
    		u += i * histogram[i];  //整幅图像的平均灰度
    	}  
    
    	int threshold;    
    	float maxVariance=0;  
    	float w0 = 0, avgValue  = 0;
    	for(int i = 0; i < 256; i++) 
    	{  
    		w0 += histogram[i];  //假设当前灰度i为阈值, 0~i 灰度像素所占整幅图像的比例即前景比例
    		avgValue  += i * histogram[i]; //avgValue/w0 = u0
    
    		float t = avgValue/w0 - u;  //t=u0-u
    		float variance = t * t * w0 /(1 - w0);  
    		if(variance > maxVariance) 
    		{  
    			maxVariance = variance;  
    			threshold = i;  
    		}  
    	}  
    
    	return threshold;  
    } 
    

    代码运行结果:
    2
    图2.otsu程序运行结果图2.otsu程序运行结果2.otsu

    代码下载:http://download.csdn.net/detail/u011285477/9584189

    博客链接:http://blog.csdn.net/u011285477/article/details/52004513

    参考资料:
    [1]Otsu N. A threshold selection method from gray-level histograms[J]. Automatica, 1975, 11(285-296): 23-27.

    展开全文
  • 大津法算阈值.txt

    2019-08-31 16:33:27
    灰度摄像头二值化计算阈值的方法有双峰法、迭代法、大津法等,双峰法原理简单算法复杂,迭代法计算量过大计算时间长,这里提供了大津法算阈值,比较适合于单片机灰度摄像头二值化计算动态阈值。
  • 大津法程序

    2013-10-23 19:51:18
    最大类间方差法是由日本学者大津于1979年提出的,是一种自适应的阈值确定的方法,又叫大津法,简称OTSU。它是按图像的灰度特性,将图像分成背景和目标2部分。背景和目标之间的类间方差越大,说明构成图像的2部分的差别越...
  • 大津法和迭代法

    2020-05-27 16:44:31
    利用ostu方法(大津法)求图像二值分割的全局最优阈值,显示分割后的效果,并与迭代法进行比较。 测试程序 clc clear f = imread('Fig1013(a)(scanned-text-grayscale).tif'); figure,subplot(2,2,1), imshow(f) ...

    利用ostu方法(大津法)求图像二值分割的全局最优阈值,显示分割后的效果,并与迭代法进行比较。

    • 测试程序
    clc
    clear
    f = imread('Fig1013(a)(scanned-text-grayscale).tif');
    figure,subplot(2,2,1), imshow(f)
    title('原始图像')
    subplot(2,2,2), imhist(f)
    T = 0.5*(double(min(f(:))) + double(max(f(:))));
    done = false;
    while ~done
        g = f>=T;
        Tnext = 0.5*(mean(f(g)) + mean(f(~g)));
        done = abs(T - Tnext) < 0.5;
        T = Tnext;
    end
    g = f<=T;
    subplot(2,2,3), imshow(g)
    title('使用迭代方法得到的阈值处理后的图像')
    T2 = Otsu(f);
    g=imbinarize(f,T/255);
    subplot(2,2,4), imshow(g);
    title('使用大津法计算阈值处理后的图像');
    
    • Otsu.m
    function ThreshValue = Otsu(Imag)
    iMax = max(Imag(:));              % 最大值
    iMin = min(Imag(:));               % 最小值
    T = iMin:iMax;                        % 灰度值范围
    Tval = zeros(size(T));               % 方差
    [iRow, iCol] = size(Imag);        % 数据维度大小
    imagSize = iRow*iCol;            % 像素点数量
    % 遍历灰度值,计算方差
    for i = 1 : length(T)
        TK = T(i);
        iFg = 0;          % 前景
        iBg = 0;          % 背景
        FgSum = 0;    % 前景总数
        BgSum = 0;    % 背景总数
        for j = 1 : iRow
            for k = 1 : iCol
                temp = Imag(j, k);
                if temp > TK
                    iFg = iFg + 1;      % 前景像素点统计
                    FgSum = FgSum + temp;
                else
                    iBg = iBg + 1;      % 背景像素点统计
                    BgSum = BgSum + temp;
                end
            end
        end
        w0 = iFg/imagSize;      % 前景比例
        w1 = iBg/imagSize;     % 背景比例
        u0 = FgSum/iFg;         % 前景灰度平均值
        u1 = BgSum/iBg;        % 背景灰度平均值
        Tval(i) = w0*w1*(u0 - u1)*(u0 - u1);     % 计算方差
    end
    [~, flag] = max(Tval);             % 最大值下标
    ThreshValue = T(flag);
    
    • 结果截图

    在这里插入图片描述
    部分代码引用于: Otsu.m.

    展开全文
  • delphi版大津法算法

    2017-11-03 16:42:48
    很简单的代码,没有用OPENCV,简单描述大津法的改进算法。分割效果对背景和前景对比很大时有效。 本程序在delphi10.2下编译通过
  • 主要包括数字形态滤波(开闭运算组成)以及大津法即OTSU求最适合值
  • 大津法自动阈值IDL版

    2017-12-24 18:29:26
    大津法自动阈值IDL版,包括IDL源代码以ENVI工具,博客地址:www.ixxin.cn
  • 大津法阈值化

    2013-04-29 11:19:42
    基于经典的大津法进行黑折二值化代码 代码内有注释
  • 大津法Python实现

    2020-09-01 14:44:16
    大津法Python实现 1.简介 在计算机视觉和图像处理中,大津法被用于自动获取图像的阈值,或者将灰度图像转换为二值化图像。该算法假设图像包含两个类别的像素(前景像素和背景像素),然后它计算一个最优的阈值用于...
  • 大津法理解

    2015-01-30 02:41:00
    大津法的原理上来讲,该方法又称作最大类间方差法,因为按照大津法求得的阈值进行图像二值化分割后,前景与背景图像的类间方差最大(何为类间方差?原理中有介绍)。 原理: 对于图像I(x,y),前景(即目标)和背景...
  • 数字图像处理大津法阈值分割
  • OpenCV大津法二值化

    2021-01-29 15:53:03
    OpenCV大津法二值化 大津法(OTSU)是一种确定图像二值化分割阈值的算法,由日本学者大津于1979年提出。从大津法的原理上来讲,该方法又称作最大类间方差法,因为按照大津法求得的阈值进行图像二值化分割后,前景与...
  • opencv大津法阈值分割

    2012-08-08 22:14:48
    opencv大津法阈值分割 很不错的算法
  • OSTU大津法自动阈值

    2012-10-31 14:55:00
    OSTU大津法,图像自动阈值,C语言实现
  • 内含大津法优化(优化内容见个人博客),PID控制电机舵机算法,动态P,虚线识别等多种算法,小车轻松上2m啦(逐飞库,IAR8.2,版本过低可能打不开)
  • 最大类间差法(大津法)分割图像m文件 ostu
  • 大津法计算图像阈值

    2013-12-26 21:03:14
    图像自适应阈值计算方法--大津法c++程序,工程基于vs2005+opencv210实现。下载资源后,如果与自己使用的opencv版本不一致,则需要对工程进行简单配置才能正确运行。
  • 大津法转化二值图像

    2014-05-20 20:11:02
    大津法转化二值图自己写的 用maltlab function功能调用就行了
  • 灰度图像动态阈值 全局动态阈值法:大津法 OSTU/OTSU 封装完整,移植方便 优化后的(优化前运行需要10ms,优化后需要1ms) 适合智能车图像处理
  • 大津法C语言实现方法

    热门讨论 2009-04-05 19:48:55
    大津法 图像 二值化 大津(OTSU)法求两值化阈值 包含熵法取阈值
  • 大津法进行omr识别

    千次阅读 2014-02-24 13:11:10
    大津法实际上是对集合的一个二分类,大津法是作用于某覆范空间M,如果M有进行二分类的需求。可以用大津法进行集合的两分类。
  • 大津法 大津法流程 大津法代码 function [ output , thread1 ] = Dajin( f ) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Dajin():利用迭代法寻求图像的阈值 % f 输入图像 % output 输出图像 % ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 638
精华内容 255
关键字:

大津法