精华内容
下载资源
问答
  • 外层代码: $("#main_frm").load(function () { var frm_height = $(this).contents().find("body").height(); $(this).height(frm_height); resize_bottom_box(); }); 转载于:...

    假设有 ifrmae 的 id 为 main_frm

    内部代码:

    <script>
        alert($(document).height());
        $(window.parent.document).find("#main_frm").load(function () {
            // 先重置父级ifrmae的高度,然后再设置iframe内部的
            var main_frame = $(window.parent.document).find("#main_frm");
            main_frame.css("height","auto");//重置父级
            var thisheight = $(document).height() + 30;
            main_frame.height(thisheight);
        });
    </script>

     

    外层代码:

    <script>
        $("#main_frm").load(function () {
            var frm_height = $(this).contents().find("body").height();
    
            $(this).height(frm_height);
            resize_bottom_box();
        });
    </script>

    转载于:https://my.oschina.net/zhupengdaniu/blog/1487563

    展开全文
  • Java的内层和外层类(转)[@more@]什么是inner class?内层类就是在另一个类的内部定义的一个类,定义这个类的类被称作外层类.内层类最大的优点在于它拥有对在外层类中定义的所有变量和方法的访问权.这也是内层类非常....
    Java的内层类和外层类(转)[@more@]什么是inner class?
    内层类就是在另一个类的内部定义的一个类,定义这个类的类被称作外层类.内层类最大的优点在于它拥有对在外层类中定义的所有变量和方法的访问权.这也是内层类非常适合于创建适配器的原因;内层类的另一个优点是用户可以看到它们实例化一个接口的实例,如下代码(这
    是按钮单击事件的代码):
    //outer class is "Frame1"
    button1.addActionListener(new java.awt.event.ActionListener(){
    public void actionPerformed(ActionEvent e){
    button1_actionPerformed(e); //button1_actionPerformed(e)方法定义在Fr
    ame1中
    }
    });
    其中:
    java.awt.event.ActionListener(){
    public void actionPerformed(ActionEvent e){
    button1_actionPerformed(e);
    }
    }
    这就是定义的一个内层类!事实上ActionListener是一个接口,其后的{}中的内容是这个内层类的唯一的一个方法:public void actionPerformed(ActionEvent e);这个内层类没有任何属性.这个方法中的唯一动作就是调用了按钮单击的方法----button1_actionPerformed
    (e)
    ----这个方法在外层类Frame1中定义:我们的处理就在这个方法中,比如我们可以写:
    void button1_actionPerformed(ActionEvent e){
    System.exit(0);
    }
    在这里,我们看到了内层类在调用外层类的方法----button1_actionPerformed(e).同时,我们注意到该内层类定义的前面的"new",她把这个内层类实例化了!
    匿名类和命名类
    在上面这段代码中,定义的内层类没有类名,这是因为这个类只被使用了一次,是一个"一次性"类,即匿名类.不用担心这个类的名字,Java会在背后帮我们做这些.在编译之后,可以在项目目录下找到这些类,它们具有这样的名字:Frame1$1.class,Frame1$2.class等等,以此类推.我们也可以使用这项技术如:
    Button newButton = new Button(){
    public void someNewMethod(){
    /* Defination of extra method here */
    }
    };
    这里,newButton对象是正常的java.awt.Button,其中含有为它定义的一个额外方法.当想在一个内层类内创建多个对象时,要使用命名类,而不要使用匿名类.实际上命名类在本质上和匿名类没有什么不同,其代码如下:
    public Frame1 extends DecoratedFrame{
    ...
    public Frame1(){
    ...
    try{
    jbInit();
    }
    catch(Exception e){
    e.printStackTrace();
    }
    } //end of Frame1 constructure
    private void jbInit() throws Exception{
    ...
    button1.addActionListener(new Button1Adapter());
    ...
    } //end of jbInit() method
    class Button1Adapter implements java.awt.event.ActionListener{
    public void actionPerformed(ActionEvent e){
    button1.actionPerformed(e);
    }
    }
    void button1_actionPerformed(ActionEvent e){
    /* Your own statements */
    }
    }
    这里,为名为Button1Adapter的一个类提供了正常的定义.这个类实现ActionListener接口.
    new创建适配器的一个实例,可以将其余button1对象注册到一起.内层类将会拥有这样的文件名:Frame1$Button1Adapter.class.
    上面的代码也可以不用内层类来实现.但标准的方法是应该使用内层类.各位如果感兴趣的话,也可以试试不用内层类来实现上述代码...

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/10617542/viewspace-959862/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/10617542/viewspace-959862/

    展开全文
  • openCV HSV转RGB函数解析,内层循环和外层循环对算法效率的影响

    我们先看一下openCV的源码:

    开始调用的是这个函数:

    static CvStatus CV_STDCALL
    icvHSV2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
                          CvSize size, int dst_cn, int blue_idx )


    接下来:

    static CvStatus CV_STDCALL
    icvABC2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
                          CvSize size, int dst_cn, int blue_idx, CvColorCvtFunc2 cvtfunc_32f,
                         const float* pre_coeffs, int postscale )

    再接下来就是核心运算函数:

    static CvStatus CV_STDCALL
    icvHSV2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst,
                           int dststep, CvSize size, int dst_cn, int blue_idx )


    我们分析一下,最后调用的核心函数的内容:


    static CvStatus CV_STDCALL
    icvHSV2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst,
                           int dststep, CvSize size, int dst_cn, int blue_idx )
    {
        int i;
        srcstep /= sizeof(src[0]);
        dststep /= sizeof(dst[0]);
        dststep -= size.width*dst_cn;
        size.width *= 3;


        for( ; size.height--; src += srcstep, dst += dststep )
        {
            for( i = 0; i < size.width; i += 3, dst += dst_cn )
            {
                float h = src[i], s = src[i+1], v = src[i+2];
                float b, g, r;

    //判断s 为零,本人觉得这个地方有点问题,因为浮点类型不可以这么对比

    //可以修改为

    //#define YX_FLOAT_EQUAL_ZERO(f) ((f) < FLT_EPSILON && (f) > -FLT_EPSILON)

    //当然了,你先要添加这个宏定义才行啊


                if( s == 0 )
                    b = g = r = v;
                else
                {
                    static const int sector_data[][3]=
                        {{1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}};
                    float tab[4];
                    int sector;

    //相当于 h /= 60;    因为:1.0 / 60 = 0.016666666666666666f;

                    h *= 0.016666666666666666f; 

    //这是把h界定在0~5之间
                    if( h < 0 )
                        do h += 6; while( h < 0 );
                    else if( h >= 6 )
                        do h -= 6; while( h >= 6 );
                    sector = cvFloor(h);

    //取h的小数部分
                    h -= sector;

    //下面的操作在定义中有了,不详细描述了(看下面的维基链接)

    //https://en.wikipedia.org/wiki/HSL_and_HSV
    tab[0] = v;
    tab[1] = v*(1.f - s);
    tab[2] = v*(1.f - s*h);
    tab[3] = v*(1.f - s*(1.f - h));
                    
                    b = tab[sector_data[sector][0]];
                    g = tab[sector_data[sector][1]];
                    r = tab[sector_data[sector][2]];
                }


    dst[blue_idx] = b;
    dst[1] = g;
    dst[blue_idx^2] = r;
    if( dst_cn == 4 )
    dst[3] = 0;
            }
        }


        return CV_OK;
    }


    其实,程序很简单,到这里也就结束了,没什么奇怪的地方。

    可是我把程序重新写了一遍,发现了很大的不同。

    直接读代码吧:

    这段代码是上面列举的第二个函数,分析在最后面

    static CvStatus CV_STDCALL
    icvABC2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
    CvSize size, int dst_cn, int blue_idx, CvColorCvtFunc2 cvtfunc_32f,
    const float* pre_coeffs, int postscale )
    {
    int block_size = MIN(1 << 8, size.width);
    float* buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
    int i, di, k;
    CvStatus status = CV_OK;


        dststep -= size.width*dst_cn;


        for( ; size.height--; src += srcstep, dst += dststep )
        {
            for( i = 0; i < size.width; i += block_size )
            {
                const uchar* src1 = src + i*3;
                di = MIN(block_size, size.width - i);
                
    for( k = 0; k < di*3; k += 3 )
    {
    float a = CV_8TO32F(src1[k])*pre_coeffs[0] + pre_coeffs[1];
    float b = CV_8TO32F(src1[k+1])*pre_coeffs[2] + pre_coeffs[3];
    float c = CV_8TO32F(src1[k+2])*pre_coeffs[4] + pre_coeffs[5];
    buffer[k] = a;
    buffer[k+1] = b;
    buffer[k+2] = c;
    }


                status = cvtfunc_32f( buffer, 0, buffer, 0, cvSize(di,1), 3, blue_idx );
                if( status < 0 )
                    return status;
                
                if( postscale )
                {
                    for( k = 0; k < di*3; k += 3, dst += dst_cn )
                    {
                        int b = cvRound(buffer[k]*255.);
                        int g = cvRound(buffer[k+1]*255.);
                        int r = cvRound(buffer[k+2]*255.);


                        dst[0] = CV_CAST_8U(b);
                        dst[1] = CV_CAST_8U(g);
                        dst[2] = CV_CAST_8U(r);
                        if( dst_cn == 4 )
                            dst[3] = 0;
                    }
                }
                else
                {
    for( k = 0; k < di*3; k += 3, dst += dst_cn )
    {
    int b = cvRound(buffer[k]);
    int g = cvRound(buffer[k+1]);
    int r = cvRound(buffer[k+2]);


    dst[0] = CV_CAST_8U(b);
    dst[1] = CV_CAST_8U(g);
    dst[2] = CV_CAST_8U(r);
    if( dst_cn == 4 )
    dst[3] = 0;
    }
                }
            }
        }


        return CV_OK;
    }

    其实这段代码也没有什么,只是看上去有点奇怪,怪在哪里呢?

    就是函数中本来只存在一个大循环(size.height==1),就是for( i = 0; i < size.width; i += block_size );

    内部一个循环:for( k = 0; k < di*3; k += 3 );

    问题出来了,为什么程序编写者不在内存循环中,把结果直接计算出来?实际上,作者是把内层的循环分成了3部分来完成。

    第一部分:

    for( k = 0; k < di*3; k += 3 )
    {
    float a = CV_8TO32F(src1[k])*pre_coeffs[0] + pre_coeffs[1];
    float b = CV_8TO32F(src1[k+1])*pre_coeffs[2] + pre_coeffs[3];
    float c = CV_8TO32F(src1[k+2])*pre_coeffs[4] + pre_coeffs[5];
    buffer[k] = a;
    buffer[k+1] = b;
    buffer[k+2] = c;
    }

    第二部分:

     status = cvtfunc_32f( buffer, 0, buffer, 0, cvSize(di,1), 3, blue_idx ); 即核心运算函数 icvHSV2BGRx_32f_C3CnR

    第三部分:

    for( k = 0; k < di*3; k += 3, dst += dst_cn )
    {
    int b = cvRound(buffer[k]);
    int g = cvRound(buffer[k+1]);
    int r = cvRound(buffer[k+2]);


    dst[0] = CV_CAST_8U(b);
    dst[1] = CV_CAST_8U(g);
    dst[2] = CV_CAST_8U(r);
    if( dst_cn == 4 )
    dst[3] = 0;
    }


    这三部分完全一次计算出来呀,为什么要分开呢?

    按照这个思路,本人把三个内循环程序拆开,直接计算出结果,最后得到的结论是:

    之前openCV程序的效率是:0.2738秒(图像1920*1080 debug版),而我的计算是:0.3897秒(图像1920*1080 debug版),耗时约1.4倍于openCV的源码

    从这里可以看出来,分块处理的有效性,大家有兴趣可以测试一下!

    如果再加入一层循环,也就是说最外层的大循环size.height!=1 的话,此算法的效率会有所下降,但是也相差无几!

    可以看出,算法优化的最根本的部分,在于内层循环的优化,外层循环影响并不是很大!

    展开全文
  • Java的内层和外层

    2008-05-21 04:47:00
    在这里,我们看到了内层类在调用外层类的方法----button1_actionPerformed(e).同时 ,我们 注意到该内层类定义的前面的"new",她把这个内层类实例化了! 匿名类命名类 在上面这段代码中,定义的内层类没有类名,...
    	
    
    
    
    <script type="text/javascript">
    
    google_ad_client = "pub-8800625213955058";
    
    /* 336x280, 创建于 07-11-21 */
    
    google_ad_slot = "0989131976";
    
    google_ad_width = 336;
    
    google_ad_height = 280;
    
    //
    
    </script>
    
    <script type="text/javascript"
    
    src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
    
    </script>
    
    什么是inner class?
    
    内层类就是在另一个类的内部定义的一个类,定义这个类的类被称作外层类.内层类最大
    
    的优点
    
    在于它拥有对在外层类中定义的所有变量和方法的访问权.这也是内层类非常适合于创建
    
    适配
    
    器的原因;内层类的另一个优点是用户可以看到它们实例化一个接口的实例,如下代码(这
    
    是按
    
    钮单击事件的代码):
    
        //outer class is "Frame1"
    
        button1.addActionListener(new java.awt.event.ActionListener(){
    
          public void actionPerformed(ActionEvent e){
    
            button1_actionPerformed(e); //button1_actionPerformed(e)方法定义在Fr
    
    ame1中
    
          }
    
        });
    
    其中:
    
        java.awt.event.ActionListener(){
    
          public void actionPerformed(ActionEvent e){
    
            button1_actionPerformed(e);
    
          }
    
        }
    
    这就是定义的一个内层类!事实上ActionListener是一个接口,其后的{}中的内容是这个
    
    内层
    
    类的唯一的一个方法:public void actionPerformed(ActionEvent e);这个内层类没有
    
    任何
    
    属性.这个方法中的唯一动作就是调用了按钮单击的方法----button1_actionPerformed
    
    (e)
    
    ----这个方法在外层类Frame1中定义:我们的处理就在这个方法中,比如我们可以写:
    
        void button1_actionPerformed(ActionEvent e){
    
          System.exit(0);
    
        }
    
    在这里,我们看到了内层类在调用外层类的方法----button1_actionPerformed(e).同时
    
    ,我们
    
    注意到该内层类定义的前面的"new",她把这个内层类实例化了!
    
    匿名类和命名类
    
    在上面这段代码中,定义的内层类没有类名,这是因为这个类只被使用了一次,是一个"一
    
    次性"
    
    类,即匿名类.不用担心这个类的名字,Java会在背后帮我们做这些.在编译之后,可以在项
    
    目目
    
    录下找到这些类,它们具有这样的名字:Frame1$1.class,Frame1$2.class等等,以此类推
    
    .
    
    我们也可以使用这项技术如:
    
        Button newButton = new Button(){
    
          public void someNewMethod(){
    
            /* Defination of extra method here */
    
          }
    
        };
    
    这里,newButton对象是正常的java.awt.Button,其中含有为它定义的一个额外方法.
    
    当想在一个内层类内创建多个对象时,要使用命名类,而不要使用匿名类.实际上命名类在
    
    本质
    
    上和匿名类没有什么不同,其代码如下:
    
        public Frame1 extends DecoratedFrame{
    
          ...
    
          public Frame1(){
    
            ...
    
            try{
    
              jbInit();
    
            }
    
            catch(Exception e){
    
              e.printStackTrace();
    
            }
    
          } //end of Frame1 constructure
    
          private void jbInit() throws Exception{
    
            ...
    
            button1.addActionListener(new Button1Adapter());
    
            ...
    
          } //end of jbInit() method
    
          class Button1Adapter implements java.awt.event.ActionListener{
    
            public void actionPerformed(ActionEvent e){
    
              button1.actionPerformed(e);
    
            }
    
          }
    
          void button1_actionPerformed(ActionEvent e){
    
            /* Your own statements */
    
          }
    
        }
    
    这里,为名为Button1Adapter的一个类提供了正常的定义.这个类实现ActionListener接
    
    口.
    
    new创建适配器的一个实例,可以将其余button1对象注册到一起.内层类将会拥有这样的
    
    文件
    
    名:Frame1$Button1Adapter.class.
    
    上面的代码也可以不用内层类来实现.但标准的方法是应该使用内层类.各位如果感兴趣
    
    的话,
    
    也可以试试不用内层类来实现上述代码...:-)
    
    
    
    
    
    
    
    
    展开全文
  • 内层位移换算到外层

    2019-07-10 16:17:00
    内层位移换算到外层  在3维场景功能实现中,需要制作有类似于UG中使用坐标系来转动平移节点的功能,在实现过程发现:  如果将平移层置于旋转功能层内,则:旋转时,如果事先经过了平移操作,将导致节点在...
  • 就是当内层的for循环满足条件的时候,如何结束本次内层循环 ,同时,跳过或者结束本次外层循环。后来,在网上就查阅了一些资料,自己整理了下。 1.for…else… 搭配break 结束双重循环 代码如下: for i in range(1,...
  • <style> .par { border: 5px solid #fcc; width: 300px; /*height:110px; 注意这里给外层元素设置相应高度... 或者给外层元素设置浮动,外层元素也会包裹内层元素,但不会占用文档流空间*/}.child { border: ...
  • 1、需要用的jar包: 1.commons-lang.jar 2.commons-beanutils.jar 3.commons-collections.jar ...3、通过JSONObjectHashMap来完成转换 import java.util.HashMap; import java.util.Map; import net...
  •  像这种内层函数引用了外层函数的变量(参数也算变量),然后返回内层函数的情况,称为 闭包 。  闭包的特点是返回的函数还引用了外层函数的局部变量,所以,要正确使用闭包,就要确保 引用的局部变量在函 数...
  • 有两个list是嵌套关系,外层list的每个对象有某个属性,根据该属性值不同...在每一个外层对象下又会循环内层list,要求是内层的supername属性值和外层的name属性值相等。然后输出内层的每一个对象的threadCount属性值。
  • BFC情况下人们通常在div中使用floatmargin,这会经常出现一些问题,这里就来看一下CSS使用BFC规则布局引发外层div包裹内层div的处理方法,需要的朋友可以参考下.
  • 问题同上,尽管写法上是错误的,但是我想知道内外两容器同类名的时候,怎么编译?写出来的东西是乱的,我已经试过了,我想知道他的编译方法。 不是类组合的形式哦,每只有一个类名,如: <div class="aa"&...
  • 我发布到报名在线EDU84.COM上,大家分享一下JAVA:内层方法抛出异常,外层方法捕捉并处理异常 public void methodA (){  try{  // 调用methodB  methodB();  }  catch(ExceptionType et){  // 相应处理措施...
  • 外层Fragment:FragmentManger通过addreplace方法添加到Activity中, 内存:ViewPager 通过FragmentPagerAdapter添加到外层Fragment中; 错误使用:new MyFragmentPagerAdapter(getActivity()....
  • //pc的首页数据 foreach($new_list as $k => &$val){ foreach ($val['data'] as $key => &$v) { $v['image_path'] = Util_Const::PHOTO_URL_DOMAIN_WEB.'/photo_uploader/goods/'.$v['goods_image_path'];...
  • <!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>...试过font-size=0还有其他方法都不行,把外层盒子改大点变成300.5都行。能解释一下吗
  • 当b1b2都是float=left时候,a1的高度不会被b1b2的高度撑开。 &lt;div id=“div1″&gt; &lt;div id=”div2″ style="float:left;height:200px;"&gt;&lt;/div&gt; &...
  • 两个div嵌套,当内层div的高度增长时,外层div的高度被也被撑大,而不是出现滚动条 解决方法:设置最内层div的高度overflow,注意:是最内层的div 还不行,在设置外层div的高度overflow:hidden试试...
  • 首先我们最外层设了个大div,内层设置了一个小div,内层div要设置高度,不然滚动条overflow: auto;属性不生效,然后内层div的高度要超出屏幕外,我们这里给了1000px,不然更换屏幕很长的设备类容会少了一截,并不是...
  • 这里写目录标题算法...说白了,首先把第一个元素当成最小的,然后依次后面的数组元素比较,如果找到一个比第一个元素还小的元素,就交换两个元素,直到数组末尾,没循环一次就找出来一个最小的元素放在前面 图片描
  • 作者: Super-Kerwin 原文链接:https://www.cnblogs.com/kkzhilu/p/13352940.htmlSQL优化与诊断Explain诊断Explain各参数的含义如下:列名...否则,内层的select语句一般会顺序编号,对应于其在原始语句中的位置se...
  • 1.必须保证表达式A表达式B都符合定义的数据类型,即上述例子中 "男" "女" 都属于 字符串String类型。 2.三元运算符的结果必须被使用,此处类似于定义变量,常量不能单独存在,例如在java 中,不能直接
  • shop[shop_name]={}#json文件里写入字典套字典,先定义最外层字典,然后把countprice加入 shop[shop_name]['count'] = shop_count shop[shop_name]['price'] = shop_price with open('a.json', 'w', encoding='...
  • 文章目录算法描述图片描述代码展示记忆口诀 ...一定要注意是紧邻的两个元素比较,比较出来的较大元素会继续下一个元素进行比较,直到数组末尾。 代码展示 import java.util.Arrays; import java.util.Scanner
  • 数组向量一样是存放相同类型的对象的容器 数组对比vector 数组 向量 不可变长 可变长 通过下标访问 通过下标访问 灵活性差 灵活性强 性能好 损失一些性能 数组的初始化 编译器在编译是就必须知道...
  • 之前经常是这样布局的,用一个div(id=Main)包住左边div(id=DivLeft)右边div(id=DivRight),Main随着DivLeftDivRight内容的高度而自动伸缩,从而达到动态布局的效果。 #Main{  width:980px  ...

空空如也

空空如也

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

内层和外层