2017-09-05 20:35:22 zwt154451 阅读数 1812
  • 大数据Spark实战视频教程

    大数据Spark实战视频培训教程:本课程内容涉及,Spark虚拟机安装、Spark表配置、平台搭建、快学Scala入门、Spark集群通信、任务调度、持久化等实战内容。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架,Spark,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

    34880 人正在学习 去看看 张长志

本文为博主原创,转载请注明出处:

http://blog.sina.com.cn/s/blog_156532ba70102wmjf.html

迭代法首先选择一个近似阈值T,将图像分割成两部分R1和R2,计算区域R1和R2的均值μ1和μ2,选择新的分割阈值T = (μ1 + μ2)/2 ,重复上述步骤知道μ1和μ2(或T)不再变化为止。这里我已经将迭代法写成了函数,直接调用就可以了。函数源代码如下:

function [ TK ] = diedai( I )  
% 图像分割之迭代法获取阈值  
% 形参I为原始图像灰度图,返回值为阈值    
I = imread('rice.jpg');  
ZMAX = max(I);%取出最大灰度值  
ZMIN = min(I);%取出最小灰度值  
TK = (ZMAX+ZMIN)/2;%初始阈值  
BCal = 1;  
iSize = size(I);%图像大小  
while (BCal)  
    %定义前景和背景数  
    iForeground = 0;  
    iBackground = 0;  
    %定义前景和背景灰度总和  
    ForegroundSUM = 0;  
    BackgroundSUM = 0;  
    for i = 1:iSize(1)  
        for j = 1:iSize(2)  
            tmp = I(i,j);  
            if tmp >= TK  
                %前景灰度值  
                iForeground = iForeground + 1;  
                ForegroundSUM = ForegroundSUM + double(tmp);  
            else  
                iBackground = iBackground + 1;  
                BackgroundSUM = BackgroundSUM + double(tmp);  
            end  
        end  
    end  
    %计算前景和背景的平均值  
    ZO = ForegroundSUM/iForeground;  
    ZB = BackgroundSUM/iBackground;  
    TKtemp = uint8((ZO + ZB)/2);%新的阈值  
    if TKtemp == TK  
        BCal = 0;  
    else  
       TK = TKtemp;  
    end  
    %当阈值不再变化时,迭代结束  
    end  
disp(strcat('迭代后的阈值:',num2str(TK)));  
end  灰度图。

下面简单说下怎么调用,只有一点需要注意,迭代法操作对象为灰度矩阵,不是灰度图的要先转为灰度图。代码如下:

I1 = imread('rice.jpg');  
I = rgb2gray(I1);  
TK = diedai(I);  
newI = imbinarize(I,double(TK/255));  

我这里的‘rice.jpg’图片不是灰度图,所以就要先转为灰度图。
效果图我就不放了。图像分割的方法有很多,所以并不是所有的图都适合用迭代法来分割,有的图甚至效果还会非常差,所以想要获得好的分割效果只能不断尝试好的方法。所以,加油吧!我也是刚学,写的不好请见谅!

2012-04-18 09:41:54 jhqin 阅读数 1830
  • 大数据Spark实战视频教程

    大数据Spark实战视频培训教程:本课程内容涉及,Spark虚拟机安装、Spark表配置、平台搭建、快学Scala入门、Spark集群通信、任务调度、持久化等实战内容。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架,Spark,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

    34880 人正在学习 去看看 张长志
using System;

namespace Splash.Imaging
{
    /// <summary>
    /// 图像处理:迭代法二值化阈值计算方法
    /// </summary>
    public static partial class Binarize
    {
        /// <summary>
        /// 迭代法计算阈值
        /// </summary>
        /// <param name="grayArray">灰度数组</param>
        /// <returns>二值化阈值</returns> 
        public static Int32 IterativeThreshold(Byte[,] grayArray)
        {   // 建立统计直方图
            Int32[] Histogram = new Int32[256];
            Array.Clear(Histogram, 0, 256);     // 初始化
            foreach (Byte b in grayArray)
            {
                Histogram[b]++;                 // 统计直方图
            }

            // 总的质量矩和图像点数
            Int32 SumC = grayArray.Length;    // 总的图像点数
            Int32 SumU = 0;
            for (Int32 i = 1; i < 256; i++)
            {
                SumU += i * Histogram[i];     // 总的质量矩                
            }

            // 确定初始阈值
            Int32 MinGrayLevel = Array.FindIndex(Histogram, NonZero);       // 最小灰度值
            Int32 MaxGrayLevel = Array.FindLastIndex(Histogram, NonZero);   // 最大灰度值
            Int32 T0 = (MinGrayLevel + MaxGrayLevel) >> 1;
            if (MinGrayLevel != MaxGrayLevel)
            {
                for (Int32 Iteration = 0; Iteration < 100; Iteration++)
                {   // 计算目标的质量矩和点数
                    Int32 U0 = 0;
                    Int32 C0 = 0;
                    for (Int32 i = MinGrayLevel; i <= T0; i++)
                    {   // 目标的质量矩和点数                
                        U0 += i * Histogram[i];
                        C0 += Histogram[i];
                    }

                    // 目标的平均灰度值和背景的平均灰度值的中心值
                    Int32 T1 = (U0 / C0 + (SumU - U0) / (SumC - C0)) >> 1;
                    if (T0 == T1) break; else T0 = T1;
                }
            }

            // 返回最佳阈值
            return T0;
        }        
    }
}

2019-09-25 12:59:22 Fredric_2014 阅读数 63
  • 大数据Spark实战视频教程

    大数据Spark实战视频培训教程:本课程内容涉及,Spark虚拟机安装、Spark表配置、平台搭建、快学Scala入门、Spark集群通信、任务调度、持久化等实战内容。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架,Spark,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

    34880 人正在学习 去看看 张长志
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
import cv2

"""
迭代阈值图像分割

迭代法是基于逼近的思想,其步骤如下: 
1. 求出图象的最大灰度值和最小灰度值,分别记为ZMAX和ZMIN,令初始阈值T0=(ZMAX+ZMIN)/2; 
2. 根据阈值TK将图象分割为前景和背景,分别求出两者的平均灰度值ZO和ZB 
3. 求出新阈值TK+1=(ZO+ZB)/2; 
4. 若TK==TK+1,则所得即为阈值;否则转2,迭代计算。

"""
path = 'XXXX/'
img  = cv2.imread(path + '0002cc93b.jpg')

img_gray       = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
img_gray_array = np.array(img_gray)

zmax = int(img_gray_array.max())
zmin = int(img_gray_array.min())

t    = (zmax + zmin)/2

while True:

    img_zo = np.where(img_gray_array > t, 0, img_gray_array)#大于某个值的元素由0替代
    img_bo = np.where(img_gray_array < t, 0, img_gray_array)#小于某个值的元素由0替代

    zo = np.sum(img_zo)/np.sum(img_zo != 0)
    bo = np.sum(img_bo)/np.sum(img_bo != 0)

    k = (zo + bo)/2

    if abs(t - k) < 0.01:
        break;
    else:
        t = k


#根据最新的阈值进行分割
img_gray_array[img_gray_array > t]  = 255
img_gray_array[img_gray_array <= t] = 0

plt.imshow(img_gray_array, cmap='gray')
plt.show()






2019-08-21 09:09:31 weixin_41887615 阅读数 87
  • 大数据Spark实战视频教程

    大数据Spark实战视频培训教程:本课程内容涉及,Spark虚拟机安装、Spark表配置、平台搭建、快学Scala入门、Spark集群通信、任务调度、持久化等实战内容。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架,Spark,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

    34880 人正在学习 去看看 张长志

迭代选择阈值法

原理:

代码:

//图像迭代选择阈值法
int MainWindow::DetectThreshold_pro(QImage *inputImage,int nMaxIter, int &nDiffRet)
{
    int nThreshold;
    QColor oldColor;

    nDiffRet = 0;

    //直方图数组
    int nHistogram[255] = {0};
    int bt;
    int nMax = 0;
    int nMin = 255;


    //扫描图像,计算出最大值 最小灰度的直方图
    for(int i = 0;i<inputImage->height(); i++)
    {
        for(int j = 0; j<inputImage->width(); j++)
        {
            oldColor = QColor(inputImage->pixel(j,i));
            bt = oldColor.red();

            if(bt<nMin)
            {
               nMin = bt;
            }
            if(bt>nMax)
            {
                nMax = bt;
            }

            nHistogram[bt] ++;
        }
    }


    int nTotalGray = 0;   //灰度值得和
    int nTotalPixel = 0;   //像素数的和
    int nNewThreshold = (nMax + nMin)/2; //初始阈值

    nDiffRet = nMax - nMin;

    if(nMax == nMin)
    {
        nThreshold = nNewThreshold;
    }
    else {
        nThreshold = 0;

        //迭代开始,直接迭代次数达到100 或新阈值与上一轮得到的阈值相等,迭代结束
        while(nThreshold != nNewThreshold && nMaxIter>0)
        {
            nThreshold = nNewThreshold;
            nTotalGray = 0;
            nTotalPixel = 0;

            //计算图像中小于当前的阈值部分的平均灰度
            for(int i = nMin; i<nThreshold; i++)
            {
                nTotalGray += nHistogram[i]*i;
                nTotalPixel += nHistogram[i];

            }

            int nMean1GrayValue = nTotalGray/nTotalPixel;

            nTotalGray = 0;
            nTotalPixel = 0;


            //计算图像中小于当前的阈值部分的平均灰度
            for(int i = nThreshold; i<nMax; i++)
            {
                nTotalGray += nHistogram[i]*i;
                nTotalPixel += nHistogram[i];

            }

            int nMean2GrayValue = nTotalGray/nTotalPixel;

            nNewThreshold = (nMean1GrayValue + nMean2GrayValue) / 2;
            nDiffRet = abs(nMean1GrayValue - nMean2GrayValue);

        }

    }

    return nThreshold;
}
2017-07-27 21:42:51 HJ199404182515 阅读数 2054
  • 大数据Spark实战视频教程

    大数据Spark实战视频培训教程:本课程内容涉及,Spark虚拟机安装、Spark表配置、平台搭建、快学Scala入门、Spark集群通信、任务调度、持久化等实战内容。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架,Spark,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

    34880 人正在学习 去看看 张长志

          Richardson–Lucy算法是一个在泊松噪声背景下用于图像恢复的迭代技术。其旨在通过使用期望最大化算法来使恢复图像的似然性最大化。该算法需要对图像退化的过程进行良好的估计,以实现精确恢复。导致图像模糊的原因有很多,例如目标移动,离焦透镜,或着大气湍流,这些都是可由系统的点扩散函数(PSF)来描述。

          一般的Richardson–Lucy算法收敛到最终的结果需要很多次的迭代,这限制了其在某些时间紧张型场合的使用。因此出现了许多的加速算法,David S. C. Biggs 和Mark Andrews提出的基于矢量外推原理的方法就是其中之一,该方法在速度和稳定性方面都有着重要的提高。


没有更多推荐了,返回首页