精华内容
下载资源
问答
  • 本文提出了一个数学模型,用于分析旋转电机的稳定性阈值,其中转子通过滚子轴承,轴承箱和端盖与定子连接,并且定子支脚安装在柔软的基础上。 转子的内部(旋转)阻尼是造成不稳定的唯一原因,本文对此进行了考虑。 ...
  • 为了精确地计算Kripke模型的完备性阈值,将半张量积引入到有界模型检测的完备性阈值的计算中,采用离散时间进化系统来研究Kripke模型的状态进化拓扑结构,提出了基于半张量积的有界模型检测完备性阈值的求解算法。...
  • 引入“概率包络”概念,从分析复杂多路径误差的概率分布入手,推导了两种非高斯分布的多路径误差概率分布模型,改进了两种基于污染正态分布的完好性阈值计算方法,并分别在伪距域和定位域对非高斯误差分布模型进行...
  • 我们基于回路树对偶性,对两个回路及以上回路的散射幅度的统一性阈值和异常阈值进行了首次综合分析,并显示了当所有森林都存在时,如何以有效方式局部消除非因果非物理阈值 双重带壳削减被认为是其中之一。...
  • 以一类布尔方程组形式的NP问题可满足性阈值估计为研究目的,通过将高斯消去算法与摘叶算法相结合的方法给出了一种求解该问题的完全算法,并通过不同参数条件下对大量随机实例进行数值实验得到了原问题可满足性阈值的...
  • 为了精确地计算Kripke模型的完备性阈值,将半张量积引入到有界模型检测的完备性阈值的计算中,采用离散时间进化系统来研究Kripke模型的状态进化拓扑结构,提出了基于半张量积的有界模型检测完备性阈值的求解算法。...
  • 在本文中,借助120 Hz 2场FSC显示器进行了感知实验,以研究在标准色彩空间中具有恒定白点的不同色相方向上颜色分解可见阈值。 实验结果表明,当使用不同的子场颜色进行时间组合时,颜色分解可见是多种多样的...
  • 所属栏目:
  • 正规(k,s)-SAT的可满足性阈值
  • 基于稳定性阈值的亲和力传播及其应用
  • 行业资料-电子功用-基于易失性阈值转变器件的神经元电路.pdf
  • 规则随机(k,s)-SAT问题的可满足性阈值的上限
  • 行业分类-设备装置-用于关键性阈值控制的系统、方法、设备和计算机可读媒体
  • 在文本相似检测中,如何确定相似的阈值? 在对文档进行simhash之后, 对汉明距离小于4的文档进行相似度计算,这里的阈值怎么确定呢?
  • 基于差异的变压器直流电阻变化量阈值分析,王科,李鹤健,变压器绕组连同套管直流电阻变化量是预试试验中的一个关键指标,目前试验规程规定的阈值过于笼统,尚缺乏相关差异的分析研究。
  • 自适应阈值分割

    千次阅读 2020-03-07 17:13:06
    这种方法一般称为全局阈值分割,接下来想介绍的是一种局部阈值分割算法,其原理很简单,通俗地讲就是图片的每个局部都会通过处理得到一个阈值,这个区域就用这个阈值来进行分割,同理,每个区域都有不同的阈值来处理...

    1.原理
           最简单的阈值分割即为手动设置阈值对图像进行二值化,大于设定的阈值像素值设置为255,小于设定阈值则为0.这种方法一般称为全局阈值分割,接下来想介绍的是一种局部阈值分割算法,其原理很简单,通俗地讲就是图片的每个局部都会通过处理得到一个阈值,这个区域就用这个阈值来进行分割,同理,每个区域都有不同的阈值来处理,如何来获取这个阈值就是整个算法的关键。
           这里用opencv的API接口来进行说明,opencv库有接口函数
    void adaptiveThreshold(InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
    src为输入图像,
    dst为输出图像,
    maxValue为设定的像素最大值,
    adptiveMethod为使用的滤波方法,opencv给出了两种方法,分别为ADAPTIVE_THRESH_MEAN_C 和ADAPTIVE_THRESH_GAUSSIAN_C,
    thresholdType为阈值类型,THRESH_BINARY 和THRESH_BINARY_INV,
    blockSize指的是邻域的大小,也就是通常说的核的大小,一般为奇数,
    C为阈值的偏移量。
            当使用ADAPTIVE_THRESH_MEAN_C方法时阈值为邻域的均值减去C,当使用ADAPTIVE_THRESH_GAUSSIAN_C方法时,阈值为邻域的高斯均值减去C。

    2.代码展示
    自己的自适应阈值分割方法,加入了中值滤波

    #include<opencv2/opencv.hpp>
    #include<iostream>
    
    using namespace std;
    using namespace cv;
    
    enum FliterMethod {
     meanFliter,
     gaaussianFliter,
     medianFliter
    };
    void AdaptiveThreshold(Mat &src, Mat &dst,double Maxval, int Subsize,double C ,FliterMethod method )
    {
     if (src.channels() > 1)
      cvtColor(src,src,CV_RGB2GRAY);
     Mat smooth;
     switch (method)
     {
     case meanFliter:
      blur(src, smooth, Size(Subsize, Subsize));
      break;
     case gaaussianFliter:
      GaussianBlur(src, smooth, Size(Subsize, Subsize), 0, 0);
      break;
     case medianFliter:
      medianBlur(src, smooth, Subsize);
      break;
     default:
      break;
     }
     smooth = smooth - C;
     src.copyTo(dst);
     int r = dst.rows;
     int c = dst.cols;
     for (int i = 0; i < r; i++)
     {
      for (int j = 0; j < c; j++)
      {
       if (dst.at<uchar>(i,j) > smooth.at<uchar>(i,j))
        dst.at<uchar>(i,j) = Maxval;
       else
        dst.at<uchar>(i,j) = 0;
      }
     }
    }
    

    为了看下实时处理的效果,调用了电脑摄像头,代码如下

    int Capture() {
     VideoCapture cap;
     cap.open(0);
     Mat frame;
     //Mat src;
     if (!cap.isOpened())
      return -1;
     while (1)
     {
      cap.read(frame);
      if (frame.empty())
       break;
      //GaussianBlur(frame, src, Size(5, 5), 3, 3);
      Mat src,tmp;
      AdaptiveThreshold(frame, src, 255, 7, 5, meanFliter);
      adaptiveThreshold(frame, tmp, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 7, 10);
      //imshow(" ", frame);
      imshow("AdaptiveThreshold",src);
      imshow("opencv", tmp);
      waitKey(10);
     }
     cap.release();
     destroyAllWindows();
    }

    以下为测试代码

    int main()
    {
     Mat img = imread("C:/Users/94077/Desktop/QQ截图20200307162029.bmp");
     Mat src,tmp;
     AdaptiveThreshold(img, src, 255, 7, 10, gaaussianFliter);
     adaptiveThreshold(img, tmp, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY,7, 10);
     imshow("function", src);
     imshow("opencv", tmp);
     waitKey(0);
     //Capture();
     return 0}
    

    3.结果展示
           这里放几张处理的图片对比一下,发现还是opencv的库函数处理效果好一点,但是针对不同的图片,在某些时候中值滤波的效果可能要比其余两种效果好。
    在这里插入图片描述在这里插入图片描述

    展开全文
  • 阈值分割python实现

    千次阅读 多人点赞 2019-09-28 18:01:43
    3、otsu阈值处理 import cv2 import numpy as np from scipy import signal import math def calcGrayHist(image): rows,cols=image.shape grayHist=np.zeros([256],np.uint64) for r in range(rows): for c ...

    1、直方图技术法

    import cv2
    import numpy as np
    from scipy import signal
    import math
    def calcGrayHist(image):
        rows,cols=image.shape
        grayHist=np.zeros([256],np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]]+=1
        return grayHist
    def threshTwoPeaks(image):
        histogram=calcGrayHist(image)
        maxLoc=np.where(histogram==np.max(histogram))
        firstPeak=maxLoc[0][0]
        measureDists=np.zeros([256],np.float32)
        for k in range(256):
            measureDists[k]=pow(k-firstPeak,2)*histogram[k]
        maxLoc2=np.where(measureDists==np.max(measureDists))
        secondPeak=maxLoc2[0][0]
        thresh=0
        if firstPeak>secondPeak:
            temp=histogram[int(secondPeak):int(firstPeak)]
            minLoc=np.where(temp==np.min(temp))
            thresh=secondPeak+minLoc[0][0]+1
        else:
            temp=histogram[int(firstPeak):int(secondPeak)]
            minLoc=np.where(temp==np.min(temp))
            thresh=firstPeak+minLoc[0][0]+1
        threshImage_out=image.copy()
        threshImage_out[threshImage_out>thresh]=255
        threshImage_out[threshImage_out<=thresh]=0
        return (thresh,threshImage_out)
    image=cv2.imread("/home/xiaomingming/profile/xmm.jpg",cv2.IMREAD_GRAYSCALE)
    cv2.imshow("image",image)
    thresh,out=threshTwoPeaks(image)
    print(thresh)
    cv2.imshow("out",out)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    2、熵算法

    import cv2
    import numpy as np
    from scipy import signal
    import math
    def calcGrayHist(image):
        rows,cols=image.shape
        grayHist=np.zeros([256],np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]]+=1
        return grayHist
    def threshEntroy(image):
        rows,cols=image.shape
        grayHist=calcGrayHist(image)
        normGrayHist=grayHist/float(rows*cols)
        zeroCumuMoment=np.zeros([256],np.float32)
        for k in range(256):
            if k==0:
                zeroCumuMoment[k]=normGrayHist[k]
            else:
                zeroCumuMoment[k]=zeroCumuMoment[k-1]+normGrayHist[k]
        entropy=np.zeros([256],np.float32)
        for k in range(256):
            if k==0:
                if normGrayHist[k]==0:
                    entropy[k]=0
                else:
                    entropy[k]=-normGrayHist[k]*math.log10(normGrayHist[k])
            else:
                if normGrayHist[k]==0:
                    entropy[k]=entropy[k-1]
                else:
                    entropy[k]=entropy[k-1]-normGrayHist[k]*math.log10(normGrayHist[k])
        fT=np.zeros([256],np.float32)
        ft1,ft2=0.0,0.0
        totalEntroy=entropy[255]
        for k in range(255):
            maxFront=np.max(zeroCumuMoment[0:k+1])
            maxBack=np.max(zeroCumuMoment[k+1:256])
            if maxFront==0 or zeroCumuMoment[k]==0 or maxFront==1 or zeroCumuMoment[k]==1 or totalEntroy==0:
                ft1=0
            else:
                ft1=entropy[k]/totalEntroy*(math.log10(zeroCumuMoment[k])/math.log10(maxFront))
            if maxBack==0 or 1-zeroCumuMoment[k]==0 or maxBack==1 or 1-zeroCumuMoment[k]==1:
                ft2=0
            else:
                if totalEntroy==0:
                    ft2=math.log10(1-zeroCumuMoment[k])/math.log10(maxBack)
                else:
                    ft2=(1-entropy[k]/totalEntroy)*(math.log10(1-zeroCumuMoment[k])/math.log10(maxBack))
            fT[k]=ft1+ft2
        threshLoc=np.where(fT==np.max(fT))
        thresh=threshLoc[0][0]
        threshold=np.copy(image)
        threshold[threshold>thresh]=255
        threshold[threshold<=thresh]=0
        return (thresh,threshold)
    image=cv2.imread("/home/xiaomingming/profile/dog.jpg",cv2.IMREAD_GRAYSCALE)
    cv2.imshow("image",image)
    thresh,out=threshEntroy(image)
    print(thresh)
    out=np.round(out)
    out.astype(np.uint8)
    cv2.imshow("out",out)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    3、otsu阈值处理

    import cv2
    import numpy as np
    from scipy import signal
    import math
    def calcGrayHist(image):
        rows,cols=image.shape
        grayHist=np.zeros([256],np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]]+=1
        return grayHist
    def otsu(image):
        rows,cols=image.shape
        grayHist=calcGrayHist(image)
        uniformGrayHist=grayHist/float(rows*cols)
        zeroCumuMoment=np.zeros([256],np.float32)
        oneCumuMoment=np.zeros([256],np.float32)
        for k in range(256):
            if k==0:
                zeroCumuMoment[k]=uniformGrayHist[0]
                oneCumuMoment[k]=k*uniformGrimport cv2
    import numpy as np
    from scipy import signal
    import math
    def calcGrayHist(image):
        rows,cols=image.shape
        grayHist=np.zeros([256],np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]]+=1
        return grayHist
    def adaptiveThresh(I,winSize,ratio=0.15):
        I_mean=cv2.boxFilter(I,cv2.CV_32FC1,winSize)
        out=I-(1.0-ratio)*I_mean
        out[out>=0]=255
        out[out<0]=0
        out=np.round(out)
        out=out.astype(np.uint8)
        return out
    image=cv2.imread("/home/xiaomingming/profile/xmm.jpg",cv2.IMREAD_GRAYSCALE)
    cv2.imshow("image",image)
    out=adaptiveThresh(image,(11,11))
    #out=np.round(out)
    #out.astype(np.uint8)
    cv2.imshow("out",out)
    cv2.waitKey(0)
    cv2.destroyAllWindows()ayHist[0]
            else:
                zeroCumuMoment[k]=zeroCumuMoment[k-1]+uniformGrayHist[k]
                oneCumuMoment[k]=oneCumuMoment[k-1]+k*uniformGrayHist[k]
        mean=oneCumuMoment[255]
        variance=np.zeros([256],np.float32)
        for k in range(255):
            if zeroCumuMoment[k]==0 or zeroCumuMoment[k]==1:
                variance[k]=0
            else:
                variance[k]=math.pow(mean*zeroCumuMoment[k]-oneCumuMoment[k],2.0)/(zeroCumuMoment[k]*(1-zeroCumuMoment[k]))
        threshLoc=np.where(variance[0:255]==np.max(variance[0:255]))
        thresh=threshLoc[0][0]
        threshold=np.copy(image)
        threshold[threshold>thresh]=255
        threshold[threshold<=thresh]=0
        return (thresh,threshold)
    image=cv2.imread("/home/xiaomingming/profile/xmm.jpg",cv2.IMREAD_GRAYSCALE)
    cv2.imshow("image",image)
    thresh,out=otsu(image)
    print(thresh)
    out=np.round(out)
    out.astype(np.uint8)
    cv2.imshow("out",out)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    4、自适应阈值分割

    import cv2
    import numpy as np
    from scipy import signal
    import math
    def calcGrayHist(image):
        rows,cols=image.shape
        grayHist=np.zeros([256],np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]]+=1
        return grayHist
    def adaptiveThresh(I,winSize,ratio=0.15):
        I_mean=cv2.boxFilter(I,cv2.CV_32FC1,winSize)
        out=I-(1.0-ratio)*I_mean
        out[out>=0]=255
        out[out<0]=0
        out=np.round(out)
        out=out.astype(np.uint8)
        return out
    image=cv2.imread("/home/xiaomingming/profile/xmm.jpg",cv2.IMREAD_GRAYSCALE)
    cv2.imshow("image",image)
    out=adaptiveThresh(image,(11,11))
    #out=np.round(out)
    #out.astype(np.uint8)
    cv2.imshow("out",out)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    展开全文
  • 目的:为了为修订当前的职业噪声诱发耳聋(ONID)诊断标准提供理论依据,我们通过分析不同的高频听力阈值加权值(HFTWV)来评估ONID的程度。 方法:回顾研究评估2016年1月至2017年1月在中国广东省的ONID患者的...
  • 为更好地对滑坡进行预测预报,将作为滑坡预警重要判据的经验降雨阈值的研究现状进行分类总结,并结合滑坡产生机理加以评述。提出了经验降雨阈值目前存在的问题是受客观统计资料影响较大、降雨强度的选择问题、...
  • 最佳阈值划分问题

    千次阅读 2019-09-26 20:43:26
    这就需要找到阈值来将样本准确地划分到类别。 例如一个文本情感分类问题:情感有0(消极)、1(中性)、2(积极)三种类别。回归器返回的情感的分值分别为0.2,0.3,0.4,0.45,0.66,1.2,1.3,1.4,它们对应的类别分别为0...

    分类问题有时是个回归问题。这就需要找到阈值来将样本准确地划分到类别。

    例如一个文本情感分类问题:情感有0(消极)、1(中性)、2(积极)三种类别。回归器返回的情感的分值分别为0.2,0.3,0.4,0.45,0.66,1.2,1.3,1.4,它们对应的类别分别为0,0,1,2,1,1,2,2,需要找到两个阈值x,y,小于x的表示0类别,x和y之间的表示1类别,大于y的表示2类别。

    如果寻找最佳答案,复杂度为O(样本数^类别数)。

    如果使用贪心法,问题复杂度可以降为O(样本数)的复杂度。
    把每次寻找阈值当做一个二分类问题。这种方法能够牺牲准确性换来时间效率的提升。

    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Random;
    
    public class Main {
    Random r = new Random();
    
    class Sample {
        int score;//样本的得分
        int type;//样本的类别
    
        Sample(int score, int type) {
            this.score = score;
            this.type = type;
        }
    
        @Override
        public String toString() {
            return "(" + score + "," + type + ")";
        }
    }
    
    Sample[] generateProblem() {
        int n = r.nextInt(4) + 2;
        Sample[] a = new Sample[n];
        for (int i = 0; i < n; i++) {
            a[i] = new Sample(r.nextInt(50), r.nextInt(3));
        }
        Arrays.sort(a, Comparator.comparingInt(x -> x.score));
        return a;
    }
    
    int bruteforceScore(Sample[] a) {
        int bestI = 0, bestJ = 0;
        int bestScore = 0;
        for (int i = 0; i <= a.length; i++) {//第一个阈值
            for (int j = i; j <= a.length; j++) {//第二个阈值
                int score = getScore(a, i, j);
                if (score > bestScore) {
                    bestScore = score;
                    bestI = i;
                    bestJ = j;
                }
            }
        }
        System.out.println("ans i: " + bestI + " ans j:" + bestJ);
        return bestScore;
    }
    
    int getScore(Sample[] a, int i, int j) {
        int rightCount = 0;
        for (int k = 0; k < a.length; k++) {
            if (k < i && a[k].type == 0) {
                rightCount++;
            } else if (k >= i && k < j && a[k].type == 1) {
                rightCount++;
            } else if (k >= j && a[k].type == 2) {
                rightCount++;
            }
        }
        return rightCount;
    }
    
    int mine(Sample[] a) {
        int bestI = 0;
        long bestRightCOunt = 0;
        long rightCount = Arrays.stream(a).filter(x -> x.type != 0).count();
        for (int i = 0; i < a.length; i++) {
            if (rightCount >= bestRightCOunt) {
                bestRightCOunt = rightCount;
                bestI = i;
            }
            if (a[i].type == 0) rightCount++;
            else rightCount--;
        }
        if (rightCount >= bestRightCOunt) {
            bestI = a.length;
        }
        bestRightCOunt = 0;
        final int goodI = bestI;
        if (goodI == a.length) {
            //全0的情况
            return getScore(a, a.length, a.length);
        }
        rightCount = Arrays.stream(a).filter(x -> x.score >= a[goodI].score && x.type == 2).count();
        int bestJ = 0;
        for (int i = bestI; i < a.length; i++) {
            if (rightCount > bestRightCOunt) {
                bestRightCOunt = rightCount;
                bestJ = i;
            }
            if (a[i].type == 1) rightCount++;
            else if (a[i].type == 2) rightCount--;
        }
        if (rightCount > bestRightCOunt) {
            bestJ = a.length;
        }
        System.out.println();
        System.out.println("bestI " + bestI + " bestJ " + bestJ);
        return getScore(a, bestI, bestJ);
    }
    
    Main() {
        while (true) {
            Sample a[] = generateProblem();
            for (Sample i : a) {
                System.out.print(i);
            }
            System.out.println();
            int x = bruteforceScore(a);
            int y = mine(a);
            System.out.println(x + " " + y);
            if (x != y) break;
        }
    }
    
    public static void main(String[] args) {
        new Main();
    }
    }

    转载于:https://www.cnblogs.com/weiyinfu/p/9557525.html

    展开全文
  • 主要为大家详细介绍了python+opencv实现阈值分割的相关代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 背景:模糊连接方法已显示出其近年来在模糊对象提取中的有效。 但是,将其应用于肝血管分割任务时可能会出现两个问题。 一个是过多的计算成本,另一个是难以为最终分割选择合适的阈值。 方法:本文首先提出了一种...
  • [1]提出了Paillier密码系统的第一个阈值代理签名方案,并声称在随机预言模型中,它们的构造对于选择消息攻击和选择保证攻击是存在不可伪造的。 但是,在本文中,我们显示了他们的方案对于可以访问原始签名者的秘密...
  • 为了突出表现构造的新阈值函数的优越,通过仿真实验对文中提出的几种小.波去噪方法的均方差(MSE)和峰值信噪比(PSNR)进行对比。实验结果表明,利用新构造的阈值函数去噪,去噪后的图像.无论是视觉效果还是在均方差...
  • 视觉显著检测是机器视觉领域的关键技术之一。提出一种基于流形排名与迟滞阈值的检测方法,首先将图像划分成超像素集合,以之作为结点形成闭环图;再按照基于图的流形排名方法计算各个结点的显著值,形成图像的显著...
  • 通过阈值筛选随机森林的重要特征

    千次阅读 2019-12-22 17:03:52
    通过阈值筛选随机森林的重要特征 14.7 Selecting Important Features in Random Forests # 筛选重要特征 from sklearn.ensemble import RandomForestClassifier from sklearn import datasets from sklearn.feature_...

    通过阈值筛选随机森林的重要特征

    14.7 Selecting Important Features in Random Forests
    # 筛选重要特征
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import datasets
    from sklearn.feature_selection import SelectFromModel
    ​
    ​
    iris = datasets.load_iris()
    features = iris.data
    target = iris.target
    ​
    randomforest = RandomForestClassifier(random_state=0, n_jobs=-1)# create object that selects features with importance greater
    # than or requal to a threshold
    # 选择重要性大于阈值的特征
    selector = SelectFromModel(randomforest, threshold=0.9)
    # 创建新的特征矩阵
    features_important = selector.fit_transform(features, target)
    model = randomforest.fit(features_important, target)
    
    展开全文
  • 数字图像处理 图像阈值分割 均匀度量法 算法源代码
  • 影响力传播的线性阈值模型: 网络中连接任意两个节点u,v之间的边都有权重,任意一个节点它的各个邻居节点的边的权重之和为1,即 N(v):neighbors of v. 网络中的节点分为已激活节点和未激活节点,每个节点都有一...
  • 小波变换和小波阈值法去噪

    万次阅读 多人点赞 2017-07-24 18:05:38
    小波变换是一种信号的时间——尺度(时间——频率)分析方法,它具有多分辨分析的特点,而且在时频两域...在以上过程中,小波基和分解层数的选择,阈值的选取规则,和阈值函数的设计,都是影响最终去噪效果的关键因素。
  • matlab开发-三角法灰度阈值。计算阈值三角形方法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 193,732
精华内容 77,492
关键字:

性阈值