छोटे हीरे वर्ग एल्गोरिथ्म

Question

डायमंड स्क्वायर एल्गोरिदम एक फ्रैक्टल टेरेन (ऊंचाई) है जो एल्गोरिथ्म उत्पन्न करता है। आप एक अच्छा विवरण पा सकते हैं कि यह यहाँ कैसे काम करता है:

http://www.gameprogrammer.com/fractal.html (संदर्भ के रूप में प्रयुक्त)

http://www.playfuljs.com/realistic-terrain-in-130-lines/ (ग्रेट जेएस कार्यान्वयन, शायद आप उसके रेंडरर को चुराना चाहें। यहां एक नज़र डालें कि यह एल्गोरिथ्म http: // डेमो के लिए क्या सक्षम है । playfuljs.com/terrain/ ।)

सामान्य विचार यह है कि आपके पास बीज (ए) के रूप में 4 कोने हैं, और उन चार कोनों को औसतन और -0.5 और 0.5 (बी) के बीच यादृच्छिक मान जोड़कर केंद्र बिंदु की ऊंचाई की गणना करें। यदि आप इसे ग्रिड पर लागू करते हैं तो आपको फिर से हीरों का एक ग्रिड मिलता है (चौकों 45 ° तक फ़िर जाता है) और आप उसी (सी, डी) को दोहराते हैं, लेकिन यादृच्छिक सीमा छोटी हो जाती है, जैसे -0.125 से 0.125 आदि।

आपके प्रोग्राम को कई इनपुट्स स्वीकार करने होंगे:

• एक पूर्णांक l=1,2,3,...जो वर्ग ग्रिड के आकार को लंबाई के साथ निर्धारित करता है 2^l+1। इसमें l=10आपको लगभग एक मिलियन नंबर स्टोर करने होंगे।
• प्रत्येक कोने के लिए चार बीज (फ्लोटिंग पॉइंट)
• एक पैरामीटर 0<h<1जो खुरदरापन ( Hलिंक में) निर्धारित करता है इसका मतलब है कि शुरू में कितनी बड़ी यादृच्छिक रेंज है
• पैरामीटर्स a,bजो यादृच्छिक श्रेणी के लिए प्रारंभिक निचले और ऊपरी सीमा का प्रतिनिधित्व करते हैं और hप्रत्येक शोधन चरण में गुणा करते हैं। (यादृच्छिक संख्या समान रूप से aऔर के बीच चुनी जाती है b।

आउटपुट में 2d ग्रिड समाप्त होना चाहिए।

तो किसी न किसी एल्गोरिथ्म इस तरह दिखेगा:

Create a square grid with sidelength 2^l+1
Place seed values in the corners
Repeat:
  |  Perform square steps
  |  Refine Range: a = a*h; b=b*h;
  |  Perform diamond steps
  |  Refine Range

एक विवरण है जिसके बारे में आपको पता होना चाहिए: ग्रिड की सीमा पर, आपके पास केवल हीरे के तीन कोने होंगे , इसलिए आपको केवल उन तीन बिंदुओं के औसत की भी गणना करनी चाहिए।

कुछ उदाहरणों का एक दृश्य

इस एल्गोरिथ्म का एक मामूली परिवर्तनशील कार्यान्वयन यहां पाया जा सकता है: समानांतर अनुमानित voxel इलाके जनरेटर

मैंने ग्रेस्केल छवि के रूप में 2 डी में विस्थापित ऊँचाई के लिए जावास्क्रिप्ट में एक छोटा सा ड्राइंग फ़ंक्शन बनाया। http://jsfiddle.net/flawr/oy9kxpsx/

यदि आप में से कोई भी फैंसी 3 डी में है और 3 डी में नक्शे देखने के लिए एक स्क्रिप्ट बना सकता है तो मुझे बताएं! =

Answer 1

जावा, 1017 बाइट्स

इनपुट एक अंतरिक्ष से अलग सूची है जैसे l s1 s2 s3 s4 h a b:।

आउटपुट एक 2d-array है जिसमें संख्याएँ होती हैं।

कार्यक्रम:

import java.util.*;import static java.lang.Math.*;class C{public static void main(String[]a){int b=a.length,d=0;float[]c=new float[b];for(;d<b;){c[d]=Float.parseFloat(a[d++]);}e=(int)(pow(2,c[0])+1);f=new float[e][e];f[0][0]=c[1];f[0][e-1]=c[2];f[e-1][0]=c[3];f[e-1][e-1]=c[4];g=c[5];float h=c[6],i=c[7];s(0,0,e-1,e-1,h,i);System.out.print(Arrays.deepToString(f));}static int e;static float[][]f;static float g;static void s(int q,int r,int s,int t,float h,float i){if(s-q<2|t-r<2|q<0|r<0|s>=e|t>=e)return;float o,p;int m=(q+s)/2,n=(r+t)/2;f[m][n]=(float)(a(q,r,s,r,q,t,s,t)+random()*(i-h)-h);d(m,r,m-q,o=h*g,p=i*g);d(q,n,m-q,o,p);d(m,t,m-q,o,p);d(s,n,m-q,o,p);}static void d(int x,int y,int e,float h,float i){float o,p;f[x][y]=(float)(a(x,y-e,x+e,y,x,y+e,x-e,y)+random()*(i-h)-h);s(x-e,y-e,x,y,o=h*g,p=i*g);s(x,y-e,x+e,y,o,p);s(x-e,y,x,y+e,o,p);s(x,y,x+e,y+e,o,p);}static float a(int...j){float k=0,l=0;for(int d=0;d<j.length;d+=2){if(j[d]<0|j[d+1]<0|j[d]>=e|j[d+1]>=e)continue;l++;k+=f[j[d]][j[d+1]];}return k/l;}}

प्रोग्राम जो इंडेंट किया जाता है और नक्शा प्रदर्शित करता है:

import java.util.*;
import java.awt.image.*;
import java.awt.*;
import javax.swing.*;
import static java.lang.Math.*;

class D{

    public static void main(String[]a){
        int b=a.length,d=0;
        float[]c=new float[b];
        for(;d<b;){
            c[d]=Float.parseFloat(a[d++]);
        }
        e=(int)(pow(2,c[0])+1);
        f=new float[e][e];
        f[0][0]=c[1];
        f[0][e-1]=c[2];
        f[e-1][0]=c[3];
        f[e-1][e-1]=c[4];
        g=c[5];
        float h=c[6],i=c[7];
        s(0,0,e-1,e-1,h,i);
        showImage(f);
    }

    static int e;
    static float[][]f;
    static float g;

    static void s(int q,int r,int s,int t,float h,float i){
        if(s-q<2|t-r<2|q<0|r<0|s>=e|t>=e)
            return;
        float o,p;
        int m=(q+s)/2,n=(r+t)/2;
        f[m][n]=(float)(a(q,r,s,r,q,t,s,t)+random()*(i+h)-h);
        d(m,r,m-q,o=h*g,p=i*g);
        d(q,n,m-q,o,p);
        d(m,t,m-q,o,p);
        d(s,n,m-q,o,p);
    }

    static void d(int x,int y,int e,float h,float i){
        float o,p;
        f[x][y]=(float)(a(x,y-e,x+e,y,x,y+e,x-e,y)+random()*(i-h)+h);
        s(x-e,y-e,x,y,o=h*g,p=i*g);
        s(x,y-e,x+e,y,o,p);
        s(x-e,y,x,y+e,o,p);
        s(x,y,x+e,y+e,o,p);
    }

    static float a(int...j){
        float k=0,l=0;
        for(int d=0;d<j.length;d+=2){
            if(j[d]<0|j[d+1]<0|j[d]>=e|j[d+1]>=e)
                continue;
            l++;
            k+=f[j[d]][j[d+1]];
        }
        return k/l;
    }

    public static void showImage(float[][] f){
        float maxHeight = Float.MIN_VALUE;
        float minHeight = Float.MAX_VALUE;
        for (float[] row : f){
            for (float height : row){
                if (height > maxHeight){
                    maxHeight = height;
                }
                if (height < minHeight){
                    minHeight = height;
                }
            }
        }
        int e = f.length;
        BufferedImage image = new BufferedImage(e, e, BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < e; x++){
            for (int y = 0; y < e; y++){
                Color color = Color.getHSBColor((float)((f[x][y] - minHeight)/(maxHeight - minHeight)), 1, 1);
                image.setRGB(x,y,color.getRGB());
            }
        }
        JFrame frame = new JFrame("Picture");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new JComponent(){

            @Override
            public void paint(Graphics g){
                g.drawImage(image, 0, 0, getWidth(), getHeight(), null);
            }

        });
        frame.setVisible(true);
        frame.setBounds(0,0,e,e);
    }

}

यहाँ जावा में एक कार्य है एक नक्शा दिखाने के लिए:

public static void showImage(float[][] map){
    float maxHeight = Float.MIN_VALUE;
    float minHeight = Float.MAX_VALUE;
    for (float[] row : map){
        for (float height : row){
            if (height > maxHeight){
                maxHeight = height;
            }
            if (height < minHeight){
                minHeight = height;
            }
        }
    }
    int size = map.length;
    BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
    for (int x = 0; x < size; x++){
        for (int y = 0; y < size; y++){
            Color color = Color.getHSBColor((float)((map[x][y] - minHeight)/(maxHeight - minHeight)), 1, 1);
            image.setRGB(x,y,color.getRGB());
        }
    }
    JFrame frame = new JFrame("Picture");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.add(new JComponent(){

        @Override
        public void paint(Graphics g){
            g.drawImage(image, 0, 0, getWidth(), getHeight(), null);
        }

    });
    frame.setVisible(true);
    frame.setBounds(0,0,size,size);
}

इन सभी छवियों का आकार है 7। 4 बीज होते हैं 5, 10, 15, और 20।

aऔर bकर रहे हैं -10और 10क्रमशः।

खुरदरापन शुरू होता है .1और .1बढ़ जाता है 1।

जल्द ही आ रहा है कोडिंग जनरेशन कोड !!!

जल्द ही आने वाली छवियाँ !!!

Comments

आपका बहुत बहुत धन्यवाद! क्या आप संभवतः एक ऐसा वर्ग प्रदान कर सकते हैं जिसके साथ सभी आवश्यक आयात होते हैं ताकि किसी बड़े संशोधन की आवश्यकता न हो? वह तो जबर्दस्त होगा!

— दोष

@flawr मैं इस पर काम कर रहा हूँ।

— TheNumberOne

बस यह काम कर रहा है, अगर आप जानते हैं कि यह कैसे करना है, तो यह बहुत अच्छा होगा यदि आप खिड़की को 'अनकैपलेस' दिखा सकते हैं। कम से कम मेरी मशीन पर आपको इसे शुरू करने से पहले इसे हर बार खोलना होगा। यहाँ बताया गया है कि मैंने कक्षा कैसे पूरी की: pastebin.com/pRAMst4d

— 23'14 को

यह कमाल लग रहा है! मैं विशेष रूप से उस सुरुचिपूर्ण तरीके को पसंद करता हूं जो आप उन सीमाओं के साथ काम कर रहे हैं जहां एक

— वर्टिस

जब आप इसे खोलते हैं तो @flawr विंडो ध्वस्त नहीं होगी।

— TheNumberOne