精华内容
下载资源
问答
  • 2.封装一类梯形对象Ladder,该类对象具有底、底和高的属性,具有初始梯形的功能、修改底、底和高的功能、周长的功能、面积的功能。 package hu; public class Ladder { private double a,b,h,c; ...

    问题描述:

    2.封装一类梯形对象Ladder,该类对象具有上底、下底和高的属性,具有初始化梯形的功能、修改上底、下底和高的功能、求周长的功能、求面积的功能。

    package hu;
    
    public class Ladder {
    private double a,b,h,c;
    public Ladder(double a,double b,double h,double c){
    	this.a=a;
    	this.b=b;
    	this.h=h;
    	this.c=c;
    }
    public void set_a(double a){
    	this.a=a;
    }
    public void set_b(double b){
    	this.b=b;
    }	
    public void set_h(double h){
    	this.h=h;
    }
    public void set_c(double c){
    	this.c=c;
    }
    public double get_a(){
    	return a;
    }
    public double get_b(){
    	return b;
    }
    public double get_h(){
    	return h;
    }
    public double get_c(){
    	return c;
    }	
    //求周长不会
    public void circum(){
    	double c1=0;
    	c1=a+b+2*c;
    	System.out.println("梯形上底,下底,高,腰为:"+a+" "+b+" "+" "+h+" "+c);
    	System.out.println("梯形周长为:"+c1);
    
    }
    public void area(){
    	double s=0;
    	s=(a+b)*h/2;
    	System.out.println("梯形上底,下底,高,腰为:"+a+" "+b+" "+" "+h+" "+c);
    	System.out.println("梯形面积为:"+s);
    }
    public static void main(String[] args) {
    		// TODO Auto-generated method stub
    	Ladder la=new Ladder(2,10,3,5);
    	la.area();
    	la.circum();
    	}
    
    }
    


    运行结果:

    梯形上底,下底,高,腰为:2.0 10.0  3.0 5.0
    梯形面积为:18.0
    梯形上底,下底,高,腰为:2.0 10.0  3.0 5.0
    梯形周长为:22.0

    展开全文
  • 图像二值的阈值

    千次阅读 2020-10-28 18:37:25
    图像二值的操作,就是寻找一个合适的阈值T,把图像中所有像素值小于等于该阈值的像素点设置为一个像素值,同时把图像中所有像素值大于该阈值的像素点设置为另一个像素值。也就是说,二值之后整幅...

    图像二值化的操作,就是寻找一个合适的阈值T,把图像中所有像素值小于等于该阈值的像素点设置为一个像素值,同时把图像中所有像素值大于该阈值的像素点设置为另一个像素值。也就是说,二值化之后整幅图像中只有两种灰度值。对于一帧8位的图像,二值化操作通常是把其像素值设置为0或255,从直观上看就是把具有灰度变化的图像设置为只有黑与白的黑白图像,0值对应黑色,255值对应白色。由此可知,二值化效果的好坏取决于阈值T的选取是否合适,阈值T就相当于黑白色的分界线。

    图像二值化的操作在数字图像处理中具有重要作用,该操作把图像变成黑白之后,可以凸显图像的重要轮廓与结构,大大减少运算量。比如在细胞的荧光成像中,常常需要把细胞区域(也即较亮区域)识别出来,很重要的一步就是把荧光成像的图像转换为二值图像,细胞区域为白色,背景区域为黑色,这样才便于检测细胞轮廓,从而识别细胞。

    最常用的求阈值算法有大津法和迭代法。本文针对荧光图像的二值化操作,详细讲解这两种算法的原理,同时对迭代法进行改进,使其可以求出更加合适的阈值。

    1. 大津法,简称为OTSU算法,属于自适应的阈值确定方法,其核心思路是寻找一个阈值T,把图像的所有像素点分成两类,一类的像素值均小于等于T(背景区域),另一类的像素值均大于T(前景区域),当这两类的类间方差取得最大值时,则认为该T值为最合适的阈值。假设背景区域所有像素点数为n0,其占图像总像素数的比例为p0,平均像素值为m0;前景区域所有像素点数为n1,其占图像总像素数的比例为p1,平均像素值为m1;图像的所有像素点数为n、平均像素值为m。那么有以下关系式:

    定义类间方差g为:

    那么由以上3式可以得到下式,这就是类间方差的计算公式。

    循环遍历图像可能取到的所有像素值作为阈值T,使g取得最大的T值则认为是最合适的阈值。比如8位图像所有可能的取值为0~255,那么分别计算出T取值0~255时的g值,当g值取得最大值,则认为找到了最佳阈值。

    使用大津法确定阈值,对一张荧光细胞图像进行二值化,得到的结果如下图所示。可以看到细胞区域基本被标识为白色区域,与背景区域区别开来。

    原图

    大津法求阈值的二值化结果图

    2. 迭代法

    迭代法也属于自适应的阈值确定方法,其核心思路是通过多轮迭代运算来一步一步逼近最佳阈值。设置一个初始阈值T0,同样把图像的所有像素点分成两类,一类的像素值均小于等于T0(背景区域),另一类的像素值均大于T0(前景区域),然后分别计算背景区域与前景区域的像素平均值m0、m1,并取m0与m1之和的一半作为下一轮迭代的阈值。如果当前轮迭代得到的阈值与上一轮迭代的阈值相差很小,则结束迭代。迭代流程如下图所示:

    使用迭代法求阈值,并对同一张荧光细胞图像进行二值化,得到的结果如下图所示。可以看到细胞区域也基本被识别出来。

    迭代法求阈值的二值化结果图

    3. 迭代法的改进。当荧光图像的背景亮度与细胞区域亮度的区别不是那么明显,也即背景区域比较亮的时候,使用大津法和迭代法确定阈值,会得到比较差的二值化结果,细胞区域不能很好地与背景区域区别开来。如下图所示,可以看到很大片的背景区域二值化之后也变成了白色。

    原图

    大津法求阈值的二值化结果图

    迭代法求阈值的二值化结果图

    由上图可知,由大津法与迭代法取得的阈值,与较亮的背景区域的像素值比较接近,导致较亮的背景区域也被误划分为细胞区域(白色区域)。下面我们对迭代法进行改进,使其求得的阈值更接近细胞区域的像素值,从而与较亮背景区域的像素值区分开来。观察迭代法的阈值更新公式,可以知道该算法每次取m0与m1之和的一半来更新阈值:

    为了使阈值更接近m1,我们修改上述公式,增大m1的比重,同时减小m0的比重:

    matlab的graythresh函数已经实现了大津法求阈值,所以在此我们不再重复实现,下面仅贴出改进之后的迭代法matlab代码:

    % 最佳阈值法获取图像二值化的阈值
    % T - 得到的最佳阈值
    % I - 输入图像
    % allow - 迭代过程中,当前迭代得到的阈值与下一轮迭代得到的阈值之差的绝对值小于allow,则认为找到了最佳阈值
    
    
    function [T] = get_threld(I, allow)
    
    
    [x,y] = size(I);                % 求出图象行列数
    b = double(I);       %把图像由整型转换为浮点型           
                            
    T_current = mean(b(:));  %取图像的均值作为初始阈值T0
    
    
    T_next = 0;                               %TT赋初值
    S0 = 0.0;               %为计算灰度大于阈值的元素的灰度总值、个数赋值
    n0 = 0.0;                       
    S1 = 0.0;                  %为计算灰度小于阈值的元素的灰度总值、个数赋值
    n1 = 0.0;                      
    d = abs(T_current-T_next);
    count = 0;
    % 记录几次循环
    while(d >= allow)                 % 迭代最佳阈值分割算法
        
        count = count+1;       %迭代次数加1
        
        for i = 1:x      %遍历每一行
            for j = 1:y  %遍历每一列
                
                if b(i,j) >= T_current   %计算图像中所有像素值大于阈值的点的像素值之和
                    S0 = S0 + b(i,j);     
                    n0 = n0 + 1;
                else             %计算图像中所有像素值小于阈值的点的像素值之和
                    S1 = S1 + b(i,j);
                    n1 = n1 + 1;
                end
    
    
            end
        end 
        
        T0 = S0/n0;   %计算图像中所有像素值大于阈值的点的像素值平均值
        T1 = S1/n1;   %计算图像中所有像素值小于阈值的点的像素值平均值
        
        %T_next = (T0+T1)/2;     %原迭代算法
        T_next = T1 + (T0-T1)*0.9;  %改进的迭代算法
        
        d = abs(T_current-T_next);    %当前迭代得到的阈值与下一轮迭代得到的阈值之差的绝对值
        T_current = T_next;         %把下一轮迭代的阈值赋值给当前轮迭代的阈值
    end
    
    
    mmax = max(max(I));
    T = T_current/double(mmax);       %把求得的阈值处以图像的最大像素值进行归一化
    
    
    end
    

    运行以上matlab代码,得到的二值化结果如下图所示。可以看到改进之后的迭代算法求取的阈值,可以很好地区分细胞区域与背景区域。因此我们的小改进还是具有不错的效果的。

    改进的迭代法求阈值的二值化结果图

    展开全文
  •  学过插值算法的同学最容易想到的就是用插值函数代替被积分函数来积分,但实际在大部分场景这是行不通的。  插值函数一般是一个不超过n次的多项式,如果用插值函数来积分的话,就会引进高次多项式积分...

      用程序来求积分的方法有很多,这篇文章主要是有关牛顿-科特斯公式。

      学过插值算法的同学最容易想到的就是用插值函数代替被积分函数来求积分,但实际上在大部分场景下这是行不通的。

      插值函数一般是一个不超过n次的多项式,如果用插值函数来求积分的话,就会引进高次多项式求积分的问题。这样会将原来的求积分问题带到另一个求积分问题:如何求n次多项式的积分,而且当次数变高时,会出现龙悲歌现象,误差反而可能会增大,并且高次的插值求积公式有可能会变得不稳定:详细原因不赘述。

      牛顿-科特斯公式解决这一问题的办法是将大的插值区间分为一堆小的插值区间,使得多项式的次数不会太高。然后通过引入参数函数

    将带有幂的项的取值范围固定在一个固定范围内,这样一来就将多项式带有幂的部分的求积变为一个固定的常数,只需手工算出来即可。这个常数可以直接带入多项式求积函数。

      上式中x的求积分区间为[a, b],h = (b - a)/n, 这样一来积分区间变为[0, n],需要注意的是从这个公式可以看出一个大的区间被分为n个等长的小区间。 这一部分具体请参见任意一本有关数值计算的书!

       n是一个事先确定好的值。

      又因为一个大的插值区间需要被分为等长的多个小区间,并在这些小区间上分别进行插值和积分,因此此时的牛顿-科特斯公式被称为:复化牛顿-科特斯公式。

       并且对于n的不同取值牛顿-科特斯有不同的名称: 当n=1时,叫做复化梯形公式,复化梯形公式也就是将每一个小区间都看为一个梯形(高为h,上底为f(t), 下底为f(t+1))。这与积分的本质:无限分隔  相同。

      当n=2时,复化牛顿-科特斯公式被称为复化辛普森公式(非美国法律界著名的那个辛普森)。

     

      我这篇文章实现的是复化梯形公式:

        

     

      首先写一个函数求节点函数值求和那部分:

        

    """
    @brief: 求和 ∑f(xk) : xk表示等距节点的第k个节点,不包括端点
            xk = a + kh (k = 0, 1, 2, ...)
            积分区间为[a, b]
            
    @param: xk      积分区间的等分点x坐标集合(不包括端点)
    @param: func    求积函数
    @return: 返回值为集合的和
    """
    def sum_fun_xk(xk, func):
        return sum([func(each) for each in xk])
    

      

      然后就可以写整个求积分函数了:

    """
    @brief: 求func积分 :
            
    @param: a  积分区间左端点
    @param: b  积分区间右端点
    @param: n  积分分为n等份(复化梯形求积分要求)
    @param: func  求积函数
    @return: 积分值
    """   
    def integral(a, b, n, func):
        h = (b - a)/float(n)
        xk = [a + i*h for i in range(1, n)]
        return h/2 * (func(a) + 2 * sum_fun_xk(xk, func) + func(b))
    

      相当的简单

     

      

      试验:

      当把大区间分为两个小区间时:

        

      分为20个小区间时:

      

      求的积分值就是这些彩色的梯形面积之和。

     

      测试代码:

    if __name__ == "__main__":
        
        func = lambda x: x**2
        a, b = 2, 8
        n = 20
        print integral(a, b, n, func)
        
        ''' 画图 '''
        import matplotlib.pyplot as plt
        plt.figure("play")
        ax1 = plt.subplot(111)
        plt.sca(ax1)
        
        tmpx = [2 + float(8-2) /50 * each for each in range(50+1)] 
        plt.plot(tmpx, [func(each) for each in tmpx], linestyle = '-', color='black')
        
        for rang in range(n):
            tmpx = [a + float(8-2)/n * rang, a + float(8-2)/n * rang, a + float(8-2)/n * (rang+1), a + float(8-2)/n * (rang+1)]
            tmpy = [0, func(tmpx[1]), func(tmpx[2]), 0] 
            c = ['r', 'y', 'b', 'g']
            plt.fill(tmpx, tmpy, color=c[rang%4])
        plt.grid(True)
        plt.show()
    

      注意上面代码中的n并不是上文开篇提到的公式中的n,开篇提到的n是指将每一个具体的插值区间(也就是小区间)等距插n个节点,复化梯形公式的n是固定的为1.

      而代码中的n指将大区间分为n个小区间。

     

    转载于:https://www.cnblogs.com/zhangte/p/6156212.html

    展开全文
  • 链表常见操作java实现一:链表初始链表长度

    万次阅读 多人点赞 2016-08-08 20:24:27
    链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向一个/或一个节点的位置的链接(“links”)。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据...

    项目github地址:bitcarmanlee easy-algorithm-interview-and-practice
    欢迎大家star,留言,一起学习进步

    1.前言

    链表是一种非常基础也非常重要的数据结构,在实际中使用非常广泛,也是各种面试里特别容易出现的类型。尤其在各大IT公司的校招中,不管笔试还是面试,链表几乎都是必出现的题型。因此不管从实际工作场景中,还是在找工作的过程中,熟练掌握链表的相关操作都显得非常重要。

    看看wiki里给链表的介绍:
    链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。

    使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。

    在计算机科学中,链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向上一个/或下一个节点的位置的链接(“links”)。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的访问往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型,因为它包含指向另一个相同类型的数据的指针(链接)。链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。链表有很多种不同的类型:单向链表,双向链表以及循环链表。

    理论部分就介绍到这里,相信只要稍微有点计算机基础的同学都能看懂是什么意思。接下来,我们上代码,看看怎么在java中实现链表的相关操作。

    2.链表的初始化

    一般链表初始化的时候,会将Node节点作为内部类至于LinkedList中。但是因为这次我们的操作比较多,代码比较复杂,为了方便起见,将Node类单独拎出来作为一个类。

    public class Node<T> {
    
        public T data;
        public Node next;
    
        public Node(T data) {
            this.data = data;
        }
    }
    
    

    Node类很简单,一个数值域data,一个指针域next,另外加一个构造方法。
    接下来看我们的MyLinkedList类:

    public class MyLinkedList {
    
        public Node head;
        public Node current;
    
        public void add(int data) {
    
            //如果头结点为空,为头结点
            if(head == null) {
                head = new Node(data);
                current = head;
            } else {
                current.next = new Node(data);
                current = current.next;
            }
        }
    
        //打印链表
        public void print(Node node) {
            if(node == null) {
                return;
            }
    
            current = node;
            while(current != null) {
                System.out.print(current.data + " ");
                current = current.next;
            }
        }
    
        //初始化链表,并且返回表头
        public Node init() {
            for(int i=0; i<10; i++) {
                this.add(i);
            }
            return head;
        }
    
        //求链表长度
        public int get_length(Node head) {
            if (head == null) {
                return -1;
            }
    
            int length = 0;
            current = head;
            while(current != null) {
                length++;
                current = current.next;
            }
    
            return length;
        }
    
    }
    

    这个MyLinkedList类中,包含有添加节点,打印链表,初始化链表,以及求链表长度的操作。MyLinkedList类以及Node类,将在我们后续的代码中多处被使用到。

    3.初步测试

    public class TestDemo {
    
        public static void main(String[] args) {
            MyLinkedList list = new MyLinkedList();
            Node head = list.init();
            list.print(head);
    
            int length = list.get_length(head);
            System.out.println();
            System.out.println("The length of list is: " + length);
        }
    }
    

    将测试代码run起来:

    0 1 2 3 4 5 6 7 8 9 
    The length of list is: 10
    
    展开全文
  • 机器学习中正则项L1和L2的直观理解

    万次阅读 多人点赞 2019-03-02 11:15:39
    正则(Regularization) 机器学习中几乎都可以看到损失函数后面会添加一个额外项,常用的额外项一般有两种,一般英文称作ℓ1ℓ1\ell_1-norm和ℓ2ℓ2\ell_2-norm,中文称作L1正则和L2正则,或者L1范数和L2范数...
  • 单目初始 单应矩阵 本质矩阵 恢复R t 三角变换 3D点 博文末尾支持二维码赞赏哦 ^_^ /* * This file is part of ORB-SLAM2 * * 单目相机初始 * 用于平面场景的单应性矩阵H(8中运动假设) 和用于非平面场景的...
  • 标准、归一、中心

    千次阅读 多人点赞 2018-10-01 23:22:52
    数据分析及挖掘中常提到的几个概念(数据的 标准、归一、中心),虽然经常在用,但可能还是有一些比较生僻的知识容易搞混淆,所以在十月国庆大家都出门高速堵车的时候抽了点时间对这些概念以我的能力和理解...
  • 数据标准/归一normalization

    千次阅读 2018-10-05 08:22:40
    这里主要讲连续型特征归一的常用方法。 连续型特征还有一种处理方式是,先分桶/分箱(如等频/等距的分)[待写]进行离散后再使用离散数据的处理方法。 离散数据处理参考[数据预处理:独热编码(One-Hot ...
  • 一、归一,标准和中心 广义的标准: (1)离差标准(最大最小值标准) (2)标准差标准 (3)归一标准 (4)二值标准 (5)独热编码标准 归一 (Normalization)、标准 ...
  • 在上一个帖子中,我们总结了离群值处理和标准,而本文将解释...(接帖) 中性 当我们提及中性时,我们往往是希望剔除待使用数据中那些多余的风险暴露。这些数据根据不同的应用场景会有不同类型,比如...
  • web页面元素的获取,有此插件,便再无所
  • 正则

    千次阅读 2019-11-15 22:11:31
    文章目录1.泛化问题2.一些方法3.提前终止法4....  一篇文章深入理解泛化提及了泛化问题,即是解决过拟合问题。本篇文章就来看看在机器学习(深度学习)领域通常是怎么解决过拟合。   神经网络的复...
  • 中兴通讯旗下的移动阅读解决方案品牌——中兴阅读,正是在此背景应用而生。   中兴阅读深耕APP开发与微信渠道传播。基于多套代码、不同技术工种、业务逻辑同步等问题,实现安卓和IOS的同步更
  • 中心(又叫零均值)和标准(又叫归一

    万次阅读 多人点赞 2018-05-19 12:39:04
    一、中心(又叫零均值)和标准(又叫归一)概念及目的?1、在回归问题和一些机器学习算法中,以及训练神经网络的过程中,通常需要对原始数据进行中心(Zero-centered或者Mean-subtraction(subtraction...
  • 一、中心(又叫零均值)和标准(又叫归一)概念及目的? 1、在回归问题和一些机器学习算法中,以及训练神经网络的过程中,通常需要对原始数据进行中心(Zero-centered或者Mean-subtraction(subtraction...
  • 在机器学习回归问题,以及训练神经网络过程中,通常需要对原始数据进行中心(零均值)与标准(归一)预处理。 目的 通过中心和标准处理,最终得到均值为0,标准差为1的服从标准正态分布的数据。 原理...
  • Java作为面向对象的语言,处理结构的数据当然也可以将其对象,这就是涉及到了转化工具。而对于XML文件来说,经常使用的是JDK 1.6开始支持的JAXB 2.0,另外还有一款叫做XStream的框架。本人在使用XStream遇到了...
  • 转载:...维基百科给出的解释:1)归一后加快了梯度下降最优解的速度;2)归一有可能提高精度。下面我简单扩展解释这两点。1 归一为什么能提高梯度下降法求解最优解的速
  • 今天参加暑期实习笔试,碰到这道题:二叉树的后序排列DBEFCA,中序排列DBAECF,那么对其做先序线索二叉树,节点E的线索指向节点?
  • 正则的作用以及L1和L2正则的区别

    万次阅读 多人点赞 2019-08-21 20:06:16
    0 正则的作用 正则的主要作用是防止过拟合,对模型添加正则项可以限制模型的复杂度,使得模型在复杂度和性能达到平衡。 常用的正则方法有L1正则和L2正则。L1正则和L2正则可以看做是损失函数的惩罚...
  • 中心和标准

    万次阅读 2017-10-31 09:35:03
    一、中心(又叫零均值)和标准(又叫归一)概念及目的? 1、在回归问题和一些机器学习算法中,以及训练神经网络的过程中,通常需要对原始数据进行中心(Zero-centered或者Mean-subtraction(subtraction...
  • 相似对角与二次型的标准联系

    千次阅读 2019-09-27 16:39:29
    n元二次型标准形,具体解题步骤: 1、写出二次型矩阵A 2、矩阵A的特征值(λ1,λ2,…,λn) 3、矩阵A的特征向量(α1,α2,…,αn) 4、改造特征向量(单位、Schmidt正交)γ1,γ2,…,γn 5、构造...
  • 一、中心(又叫零均值)和标准(又叫归一)概念及目的? 1、在回归问题和一些机器学习算法中,以及训练神经网络的过程中,通常需要对原始数据进行中心(Zero-centered或者Mean-subtraction(subtraction...
  • 案例上手 Python 数据可视

    万次阅读 多人点赞 2019-02-27 23:30:05
    课程亮点 ...数据可视是数据分析和机器学习的重要环节,比如数据清洗、特征工程、机器学习、数据分析(特别是报告)、评估等环节都会用到“数据可视”技术。 数据可视同时还广泛存在于各...
  • 4.归一和标准的区别 5.什么时候用归一?什么时候用标准? 6. 哪些模型必须归一/标准? 7、逻辑回归必须要进行标准吗? 8. 为什么需要批归一(BN)? 9. BN的好处 10、BN的原理 11、BN到底解决...
  • 重温归一(MinMaxScaler)和标准(StandardScaler)

    千次阅读 多人点赞 2019-12-30 13:37:17
    最近做一个时空序列预测的一个问题,用到了数据归一和标准,之前一直想花点时间看一下这俩的区别究竟是啥? 现在参考了几篇博文,加上自己的一些理解,来具体的总结总结。 数据的归一是无量纲,也就是忽略...
  • 神经网络是很好的函数逼近器和特征提取器,但有时它们的权值过于专门而导致过度拟合。这就是正则概念出现的地方,我们将讨论这一概念,以及被错误地认为相同的两种主要权重正则技术之间的细微差异。 1943年,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 434,326
精华内容 173,730
关键字:

上求下化