编程C,C ++,Java,PHP,Ruby,图灵,VB
计算机科学加拿大 
编程C,C ++,Java,PHP,Ruby,图灵,VB  

用户名:   Password: 
 登记登记   
 方形钻石分形图
指数 -> 一般讨论;一般交流
查看上一个主题 可打印的版本下载主题订阅本主题私人信息刷新页面 查看下一个主题
作者 信息
raknarg.




邮政发布: 星期二07,2012 6:57 PM  帖子主题:方形钻石分形图

有没有人在分形高度地图中成功使用方形钻石算法?如果是这样,我想知道你是否让我看到它。我现在正在努力做到,而且我被困了。我可以递归地进行,但如果你这样做,它不会妥善职业,因为你需要做所有的正方形,那么所有的钻石,等等。所以我无法解决它,因为它似乎使用了一种形式的递归,这改变了递归的每次进入一个新的点时如何工作:s

点是,我很困惑。有谁可以向我展示任何源代码,或解释你如何制作算法的概念?
赞助
赞助
赞助
赞助
魔鬼




邮政发布: 2012年2月8日星期三7:20  帖子主题:RE:方形钻石分形图

我最近确实写了这个确切的算法。伪代码说明是餐厅:

伪码:
代码:

int step_size =.(一些数字,可能是gcd(array_x, array_y))   //我使用array_x = 2 * step_size,array_y = step_size

尽管( step_size >= 1 ) do:
   spare_step跨整个数组
   Diamond_Step跨整个数组
完毕


Square_step和Diamond_step都同样地工作:
代码:

对于x从0到array_x by step_size do:
   对于y从0到array_y by step_size do:
        (正方形步骤或钻石步骤,适当)


我会附上我的代码,但我认为在一般讨论中禁用了附件。我当然找不到任何东西让我在这里附上一些东西。
raknarg.




邮政发布: 2012年2月8日星期三12:41 PM  帖子主题:RE:方形钻石分形图

你能告诉我吗?
魔鬼




邮政发布: 星期五,2012年2月10日11:08 AM  帖子主题:RE:方形钻石分形图

实际上,我想我会刚嵌入Java源。对不起,我花了很长时间才回复你。此外,这可能是一个有点越野车,因为我没有彻底测试它。

heightfield.java.,哪些手柄存储Heighfield和任何“包装”所必需的。
最重要的位是Get / Set方法和WriteImage()方法,其输出高度图的漂亮图片(从上面显示)。

java.:

包装中点;

导入java.awt.image.buffedimage;
导入java.io.file;
导入java.io.ioException;

导入javax.imageio.imageio;


公共类高度{
       
       公共枚举WrapMode {
                Bicylindrical {
                        public int index (int x,int y,int宽,int height) {
                                x %= width;
                                if ( x < 0 ) {
                                        x += width;
                                }
                                y %= height;
                                if ( y < 0 ) {
                                        y += height;
                                }
                               返回y * width + x;
                        }
                },
                /**
                *在x方向上,地图就像世界是一个气缸一样。
                *在Y方向上,如果我们溢出上面,则在相反的情况下流动
                * 边;如果我们溢出下面,则在另一侧流出。
                *首先执行y方向,所以我们只需要重定大小一度。       
                 */
                Spherical {
                        public int index (int x,int y,int宽,int height) {
                                // Y / Height
                                if ( y >= height ) {
                                       //高度,减去我们超过高度的金额
                                        y = height - (y % height);
                                        x += width / 2;
                                } else if ( y < 0 ) {
                                       // 0,加上我们的金额"too low" by
                                        y = - ( y % height );
                                        x += width / 2;
                                }
                                if ( y == height ) {
                                        y = height - 1;
                                }
                               
                                // X / Width
                                x %= width;
                                if ( x < 0 ) {
                                        x += width;
                                }
                               
                               返回y * width + x;
                        }
                };
               
               公共摘录INT索引(int x,int y,int宽,int height);
        }

       受保护的最终int宽度,高度;
       受保护的最终包装包装;
       
        /**
         * "Two-dimensional"阵列,按行主要订单。
         */
       受保护的Final int []阵列;
       
        public HeightField (int宽度,int heauty,wrapmode wrap) {
                this.width = width;
               这个.height = height;
                this.wrap = wrap;
               数组= new int [width * height];
        }

        public int get ( int x, int y ) {
               返回阵列[wrap.index(x,y,宽度,高度) ];
        }
       
        public void set (int x,int y,int值) {
                array [ wrap.index (x,y,宽度,高度) ] = value;
        }
       
        public int getWidth() {
                return width;
        }
       
       公共int getheight() {
                return height;
        }
       
       公共void withimage.( String fileName )抛出ioException {
                writeImage ( new File ( fileName ) );
        }
       
       公共void withimage.( File file )抛出ioException {
               bufferedimage img =新的bufferedimage(
                                width,
                                height,
                               bufferedimage.type_int_rgb.
                );

                for ( int y = 0; y < height; ++y ) {
                        for ( int x = 0; x < width; ++x ) {
                                int h = clamp ( get(x, y), 0, 255 );
                                int rgb;
                                if ( h < 128 ) {
                                        rgb = (h << 16) | (h << 8) | 255;
                                        /*
                                } else if ( h < 128 ) {
                                        rgb = (h + 30) << 16 | (h + 15) << 8 | h;
                                } else if ( h < 196 ) {
                                        rgb = (h - 128) << 16 | h << 8;
                                         */
                                } else {
                                        rgb = (h << 16) | (h << 8) | h;
                                }
                                img.setRGB (
                                                //( x + width / 2 ) % width,
                                                x,
                                                y,
                                                rgb
                                );
                        }
                }

               布尔写的= imageio.write(
                                img,
                                "BMP",
                                file
                );
               
                if ( !written ) {
                       抛出新的ioException.( "无法写图像!" );
                }
        }


       
        /**
         *
         */
       受保护的空白标准化(int bottom,int top) {
               int min = top,max =底部;
               int范围=上底;
                for (int i = 0,j =宽*高度;一世< j; ++i ) {
                        int h = array[i];
                        min = Math.min(min, h);
                        max = Math.max(max, h);
                }
               
               //现在我们知道整个高度图在于[min,max]。
               //我们重新规模,以便最小>bottom, max->top
               浮动差异= max - min;
                for (int i = 0,j =宽*高度;一世< j; ++i ) {
                        int h = array[i];
                       阵列[i] = math.round( range * ( h - min ) / difference );
                }
        }
       
       受保护的静态INT夹(int值,int min,max) {
                if ( value < min ) {
                        return min;
                }
                if ( value > max ) {
                        return max;
                }
                return value;
        }
}


main.java.,实际中点 - 位移舞蹈。请注意,它会这样做10次(在步骤之间的“持久性”不同程度)。每个人都需要几秒钟来生成(此代码没有特别优化)。

java.:
包装中点;

导入java.io.ioException;
导入java.text.numberformat;
导入java.util.random;
导入java.util.scanner;

导入minpoint.heightfield.WrapMode;

公共班主任{

       公共静态空白主(String[] args)抛出ioException {
               
                // Configuration
               Final int height_max = 255;
                final int L = 512;
               Final Int MX = 2 * L;
                final int MY = L;
               
               
               高度菲尔德HF =新高度菲尔德(MX,My,WrapMode.Pherical);

                long seed;
               扫描仪IN =新扫描仪( System.in );
                System.out.println ( "Enter a seed value (0 to "+Long.MAX_VALUE+")" );
                seed = in.nextLong();
               
               NumberFormat NF = NumberFormat.getInstance();
               nf.setmaximumFractionDigits.(1);
               nf.setminimumfractionDigits.(1);

                for (浮动持续= 0.1f;坚持< 1; persist += 0.1f ) {
                       字符串persiststring = nf.format( persist );
                               
                       long start = system.currenttimemillis();
                       中点DiSplacement.(hf,l,mx,my,height_max,持续,种子);
                        hf.normalize ( 0, 256 );
                        hf.writeImage ( "hf_"+persistString+".bmp" );
                       long end = system.currenttimemillis();

                        System.out.println (
                                        "DONE [persist = "+persistString+"] " +
                                        "("+(end-start)+" milliseconds)"
                        );
                }
        }

        protected static void中点DiSplacement.(
                       最终高度菲尔德HF,
                        final int L,
                        final int MX,
                        final int MY,
                        int range,
                       最终浮动持续,
                        final long seed
        )
        {
                /*
                 * NOTE:
                 * A is (x1, y1)
                 * B is (x2, y2)
                * a,b,c,d是原始的"corner" points
                 *         
                 *          G
                 *
                 *      B       D
                 *     
                 *  H       E       I
                 *     
                 *      A       C
                 *     
                 *          F
                 */
               
               
               随机r =新的随机(seed);

                for ( int y = 0; y < MY; y += L ) {
                        for ( int x = 0; x < MX; x += L ) {
                                hf.set ( x, y, r.nextInt ( 256 ) );
                        }
                }
               
                int step = L;
               int hompstep = l / 2;
               int x2,y2,midx,midy;

                while ( step >= 1 ) {
                       //钻石步骤整个数组......
                        for ( int y1 = 0; y1 < MY; y1 += step ) {
                                for ( int x1 = 0; x1 < MX; x1 += step ) {
                                        x2 = x1 + step;
                                        y2 = y1 + step;
                                       midx = x1 + healtep;
                                       midy = y1 + healtep;

                                        final int sum =
                                                hf.get(x1,y1) + hf.get(x1,y2) +
                                                hf.get(x2,y1) + hf.get(x2,y2);

                                        hf.set (
                                                        midx,
                                                        midy,
                                                        sum / 4 + perturb ( r, range )
                                        );
                                }
                        }

                       //整个数组的方形步骤......
                        for ( int y1 = 0; y1 < MY; y1 += step ) {
                                for ( int x1 = 0; x1 < MX; x1 += step ) {
                                        x2 = x1 + step;
                                        y2 = y1 + step;
                                       midx = x1 + healtep;
                                       midy = y1 + healtep;

                                        /*      x1  mx  x2
                                         *          G
                                         *
                                         *      B   4   D       y2
                                         *     
                                         *  H   1   E   2   I   midy
                                         *     
                                         *      A   3   C       y1
                                         *     
                                         *          F
                                         */
                                        int A = hf.get ( x1, y1 );
                                        int B = hf.get ( x1, y2 );
                                        int C = hf.get ( x2, y1 );
                                        int D = hf.get ( x2, y2 );
                                        int E = hf.get ( midx, midy );
                                        int F = hf.get (MIDX,Y1 - healstep);
                                        int G = hf.get (MIDX,Y2 + healtep);
                                        int H = hf.get (x1 - 七半,中午);
                                        int I = hf.get (x2 + halftep,midy);

                                        hf.set ( x1, midy, (A+B+E+H) / 4 ); // 1
                                        hf.set ( x2, midy, (C+D+E+I) / 4 ); // 2
                                        hf.set ( midx, y1, (A+C+E+F) / 4 ); // 3
                                        hf.set ( midx, y2, (B+D+E+G) / 4 ); // 4
                                }
                        }

                       //准备下一个迭代......
                        range *= persist;
                        step /= 2;
                        halfStep /= 2;
                }
        }

       受保护的静态INT扰动(随机r,int范围) {
                if ( range == 0 ) return 0;
                return r.nextInt ( range * 2 ) - range;
        }
}


示例映像,持久性= 0.8f。
screen.width-200)this.width = (screen.width-200)" onclick="javascript:window.open('http://i.imgur.com/KWoyu.jpg','','scrollbars=1,toolbar=0,resizable=1,menubar=0,directories=0,status=0')" alt="发布图像,可能已经减少了大小。点击图片以全屏观看。" title="发布图像,可能已经减少了大小。点击图片以全屏观看。" />
raknarg.




邮政发布: 星期五2012年2月10日星期五下午6:10  帖子主题:RE:方形钻石分形图

好的。那么你能否快速地概述广场背后的逻辑和钻石步骤?所以我可以更好地理解它?

从技术上讲,我不知道Java,但我已经弄清楚了很多,如果你这样做,它就会有所帮助
Mirhagk.




邮政发布: 星期五2012年2月10日7:25 PM  帖子主题:RE:方形钻石分形图

非常好的地形一代。
魔鬼




邮政发布: 2012年2月11日星期六晚上9:49  帖子主题:RE:方形钻石分形图

我不确定我可以更简单地解释它(当然不是今天)。你试过阅读: http://gameprogrammer.com/fractal.html ?
raknarg.




邮政发布: Sun 12,2012 10:28 AM  帖子主题:RE:方形钻石分形图

是的,我明白了。我得到了概念背后的逻辑,但不一定是你如何编码它的逻辑。它们是有区别的。就像我看见它一样,但这并不清楚
赞助
赞助
赞助
赞助
从上一个显示帖子:   
   指数 -> 一般讨论;一般交流
查看上一个主题 告诉一个朋友可打印的版本下载主题订阅本主题私人信息刷新页面 查看下一个主题

11  [ 8 Posts ]
跳到:   


Style:  
搜索: