এলোমেলো কালো-সাদা বন আঁকুন

Question

আপনার কাজটি এমন প্রোগ্রাম লেখা যা 800x600 কালো-সাদা চিত্রের সাথে বনের মতো কিছু চিত্র আঁকবে।

এটির মতো (এটি ছদ্মবেশযুক্ত ছবি):

বিধি

• আপনি কোনও বিদ্যমান চিত্র ব্যবহার করতে পারবেন না - আপনার নিখুঁতভাবে অ্যালগরিদমূর্তে চিত্র উত্পন্ন করা উচিত
• শুধুমাত্র 2 টি রঙ ব্যবহার করুন - কালো এবং সাদা (গ্রেস্কেল নেই)
• প্রতিটি সময় প্রোগ্রাম চালানো চিত্রটি নতুন হওয়া উচিত - প্রতিবার এলোমেলো
• একটি গাছ বন নয় (যাক 5 টি গাছের ন্যূনতম বলুন)
• গাছ / বন আঁকার জন্য বিশেষ গ্রন্থাগার নিষিদ্ধ করা হয়
• বেশিরভাগ ভোটের জবাব দিয়ে উত্তর দিন

Comments

এই প্রশ্নটি অফ-টপিক হিসাবে উপস্থিত বলে মনে হচ্ছে কারণ এটি প্রোগ্রামিং প্রতিযোগিতার চেয়ে আরও বেশি শিল্প প্রতিযোগিতা।

— প্রোগ্রামএফক্স

@ প্রোগ্রামগ্রামফক্স প্রোগ্রামিং আর্ট নয়? :)

— সোমনিয়ম

আমি, একের জন্য, এই চ্যালেঞ্জের জন্য কিছু এন্ট্রি দেখতে চাই এবং হতাশ হয়ে পড়ে যে এটি বন্ধ হয়ে গেছে।

— ব্র্যাডেন সেরা

আমি এই চ্যালেঞ্জ পছন্দ করি। যে উত্তরগুলি এর চেতনাতে নেই সেগুলি এতটা উত্সাহিত হবে না, তাই সমস্যা কী?

— সিজেফুরে

@cjfaure বিভিন্ন উদ্দেশ্যে, গেমসের জন্য মডেল এবং চিত্র উত্পন্ন করার জন্য।

— সোমনিয়াম

Answer 1

সি: 3863 1144 1023 999 942 927

আসল সমাধানটি প্রতি রান 2 পিএনএম ফাইল সংরক্ষণ করে (ছোঁড়ার আগে জি সংযুক্ত একটি)। যেহেতু প্রথম কয়েকটি লাইনের জন্য ডাইটিংটি সুন্দর ছিল না, প্রয়োজনের চেয়ে বেশি লাইন রেন্ডার করার জন্য হ্যাক রয়েছে এবং আউটপুট চলাকালীন শস্য রয়েছে।

গল্ফযুক্ত দ্রবণটির একটি সরল দাগ রয়েছে এবং কেবল ছদ্মবেশী চিত্রটি সংরক্ষণ করে। (জিসিসি -এসডিডি = সি 11 -ডাইপ্যান্টিক -ওয়াল-ওয়েক্সট্রা সহ কোনও সতর্কতা নেই)

3 টি মূল প্রোগ্রাম রান এবং গল্ফযুক্ত সংস্করণটির একটি রান (শেষ চিত্র) এর উদাহরণ চিত্রগুলি:

গল্ফ সংস্করণ

  #include <math.h>
  #include <time.h>
  #include <stdlib.h>
  #include <stdio.h>
  #define D float
  #define R rand()/RAND_MAX
  #define Z(a,b,c) if(10.*R>a)T(h,s,j+b+c*R,g);
  #define U a[y][x]
  #define V e[y+1][x
  #define F(x) for(i=0;i<x;++i)
  int i,x,y,W=800,H=600;unsigned char a[600][800],c;D e[601][802],r,b,k,l,m,n,f,w,
  d,q=.01;void T(D h,D s,D j,D g){r=b=0;do{j+=.04*R-.02;h+=sin(j)*q;s+=cos(j)*q;b
  +=q;g+=q;f=525/d;r=.25-g/44;m=w*f+s*f+W/2;n=2*f-h*f+H/2;f*=r;for(y=n-f-2;y<n+f+2
  ;++y)if(y>=0&&y<H)for(x=m-f-2;x<m+f+2;++x)if(x>=0&&x<W)if(k=m-x,l=n-y,f>sqrt(k*k
  +l*l))if(U>d*3)U=d*3;}while(b<10*r+12*r*R&&r>q);if(r>q){Z(2,.26,.35)Z(2,-.26,-
  .35)Z(7,-.05,.1)}}int main(){FILE* o=fopen("i","wb");srand(time(0));F(W*H){y=i/W
  ;a[y][i%W]=(y<313)?255:6e3/(2*y-H);}F(200)w=1e2*R-60,d=80.*R+5,T(0,0,1.58,0);F(W
  *H){x=i%W;y=i/W;k=U+e[y][x+1];U=-(k>0);l=(k-U)*.1;e[y][x+2]+=l*4;V]+=l*2;V+1]+=l
  *3;V+2]+=l;}fprintf(o,"P5 800 600 255 ");fwrite(a,1,W*H,o);}

মূল সংস্করণ

  #include <math.h>
  #include <stdio.h>
  #include <stdlib.h>

  #define W 800
  #define H 600
  #define SPEED 0.01
  #define HEIGHT 11.0

  #define R(m) ((double)(m) * rand() / RAND_MAX)
  #define RAD(deg) ((deg) / 180.0 * M_PI)
  #define LIMIT(x, min, max) ((x) < (min) ? (min) : (x) > (max) ? (max) : (x))

  void shade(void);
  void growTree(double dist, double side, double h, double s, double alpha, double grown);
  void plot(double dist, double side, double h, double s, double alpha, double diam);
  void dither(void);
  void writeImg(int dither);

  unsigned char img[H+10][W];
  double err[H+10+2][W+4];
  long tim;

  int main(void)
  {
     int i;
     tim = time(0);
     srand(tim);
     shade();
     for(i = 0; i < 200; ++i)
     {
        growTree(5 + R(75), -60 + R(120), 0.0, 0.0, RAD(90), 0.0);
     }
     writeImg(0);
     dither();
     writeImg(1);
  }

  void shade(void)
  {
     int y;
     for(y = -10; y < H; ++y)
     {
        double dist = H * 3.5 / (2 * y - H);
        unsigned char color = dist / 80 * 255;
        if(y <= H / 2 || dist > 80) color = 255;
        memset(img[y+10], color, W);
     }
  }

  void growTree(double dist, double side, double h, double s, double alpha, double grown)
  {
     double diam, branchLength = 0.0;

     do
     {
        alpha += R(RAD(3)) - RAD(1.5);
        h += sin(alpha) * SPEED;
        s += cos(alpha) * SPEED;
        branchLength += SPEED;
        grown += SPEED;
        diam = (1.0 - grown / HEIGHT) * 0.5;
        plot(dist, side, h, s, alpha, diam);
     } while(branchLength < 5 * diam + R(6 * diam) && diam > 0.02);

     if(diam > 0.02)
     {
        int br = 0;

        if(R(10) > 2) br++,growTree(dist, side, h, s, alpha + RAD(15) + R(RAD(20)), grown);
        if(R(10) > 2) br++,growTree(dist, side, h, s, alpha - RAD(15) - R(RAD(20)), grown);
        if(R(10) < 2 || br == 0) growTree(dist, side, h, s, alpha - RAD(2.5) + R(RAD(5)), grown);
     }
  }

  void plot(double dist, double side, double h, double s, double alpha, double diam)
  {
     int x, y;
     double scale = H / 4.0 * 3.5 / dist;
     double x0 = side * scale + s * scale + W / 2.0;
     double y0 = H / 2.0 + 2.0 * scale - h * scale;
     diam *= scale;
     h *= scale;
     s *= scale;
     for(y = y0 - diam / 2 - 2; y < y0 + diam / 2 + 2; ++y)
     {
        if(y < -10 || y >= H) continue;
        for(x = x0 - diam / 2 - 2; x < x0 + diam / 2 + 2; ++x)
        {
           double dx, dy, d;
           if(x < 0 || x >= W) continue;
           dx = x0 - x;
           dy = y0 - y;
           d = diam / 2 - sqrt(dx * dx + dy * dy) + 0.5;
           if(d > 0)
           {
              unsigned char color = dist / 80 * 255;
              if(img[y+10][x] > color) img[y+10][x] = color;
           }
        }
     }
  }

  void dither(void)
  {
     int x0, x, y;
     for(y = -10; y < H; ++y)
     {
        for(x0 = 0; x0 < W; ++x0)
        {
           double error, oldpixel;
           unsigned char newpixel;
           if(y%2) x = W - 1 - x0;
           else x = x0;
           oldpixel = img[y+10][x] + err[y+10][x+2];
           newpixel = oldpixel > 127 ? 255 : 0;
           img[y+10][x] = newpixel;
           error = oldpixel - newpixel;
           err[y+10  ][x+1+2*(1-y%2)] += error * 7 / 48;
           err[y+10  ][x+4*(1-y%2)] += error * 5 / 48;
           err[y+10+1][x  ] += error * 3 / 48;
           err[y+10+1][x+1] += error * 5 / 48;
           err[y+10+1][x+2] += error * 7 / 48;
           err[y+10+1][x+3] += error * 5 / 48;
           err[y+10+1][x+4] += error * 3 / 48;
           err[y+10+2][x  ] += error * 1 / 48;
           err[y+10+2][x+1] += error * 3 / 48;
           err[y+10+2][x+2] += error * 5 / 48;
           err[y+10+2][x+3] += error * 3 / 48;
           err[y+10+2][x+4] += error * 1 / 48;
        }
     }
  }

  void writeImg(int dither)
  {
     FILE* fp;
     char buffer[32];
     sprintf(buffer, "%ld%s.pnm", tim, dither ? "" : "g");
     fp = fopen(buffer, "wb");
     fprintf(fp, "P5\n%d %d\n255\n", W, H);
     fwrite(&img[10][0], 1, W * H, fp);
     fclose(fp);
  }

Comments

+1 টি। ছবিগুলো সুন্দর. যাইহোক, এটি জনপ্রিয়তা-প্রতিযোগিতা, কোড-গল্ফ নয়। সুতরাং, গল্ফ দরকার নেই। :)

— ভেক্টরাইজড

দেখতে বেশ ভাল, আমারও একই ধারণা ছিল তবে খুব অলস ছিলেন =) আমার মনে হয় আপনি শাখাগুলির পুনরাবৃত্তির গভীরতা এলোমেলো করে দেওয়ার চেষ্টা করতে পারেন, আমি মনে করি এটি আরও প্রাকৃতিক দেখায়।

— flawr

আমি জানি আমি এটি গল্ফ করার প্রয়োজন নেই, তবে এটি আমার জন্য সবচেয়ে মজার অংশ!

— ম্যানুয়েল ক্যাসটেন 16 ই

এটি চমত্কার।

— কুইন্টিন

এছাড়াও, আমি সেপিয়া টোনটিতে একটি অচিহ্নিত সংস্করণ রেখেছি - টকটকে! এখানে দেখুন: i.imgur.com/lCrJCp7.jpg

— ড্রিম ওয়ারিয়র

Answer 2

জাভা জঙ্গল

(954 গল্ফড)

গভীর, মোচড়ানো আন্ডারগ্রোমে পূর্ণ, এটি এমন এক বন যা সহজেই ট্র্যাজড হয় না।

এটি মূলত আস্তে আস্তে সঙ্কুচিত, মোড়কযুক্ত লতাগুলির সাথে একটি ফ্র্যাক্টাল এলোমেলো হাঁটা। আমি সেগুলির মধ্যে 75 টি আঁকছি, ধীরে ধীরে পিছনে সাদা থেকে সামনে কালো হয়ে গেছে। তারপরে আমি পুরো জিনিসটি নির্লজ্জভাবে এভেরোস কোডটি এখানে অভিযোজিত করছি।

গল্ফড: _{(কেবল অন্যরা সিদ্ধান্ত নিয়েছে বলে)}

import java.awt.*;import java.awt.image.*;import java.util.*;class P{static Random rand=new Random();public static void main(String[]a){float c=255;int i,j;Random rand=new Random();final BufferedImage m=new BufferedImage(800,600,BufferedImage.TYPE_INT_RGB);Graphics g=m.getGraphics();for(i=0;i++<75;g.setColor(new Color((int)c,(int)c,(int)c)),b(g,rand.nextInt(800),599,25+(rand.nextInt(21-10)),rand.nextInt(7)-3),c-=3.4);for(i=0;i<800;i++)for(j=0;j<600;j++)if(((m.getRGB(i,j)>>>16)&0xFF)/255d<rand.nextFloat()*.7+.05)m.setRGB(i,j,0);else m.setRGB(i,j,0xFFFFFF);new Frame(){public void paint(Graphics g){setSize(800,600);g.drawImage(m,0,0,null);}}.show();}static void b(Graphics g,float x,float y,float s,float a){if(s>1){g.fillOval((int)(x-s/2),(int)(y-s/2),(int)s,(int)s);s-=0.1;float n,t,u;for(int i=0,c=rand.nextInt(50)<1?2:1;i++<c;n=a+rand.nextFloat()-0.5f,n=n<-15?-15:n>15?15:n,t=x+s/2*(float)Math.cos(n),u=y-s/2*(float)Math.sin(n),b(g,t,u,s,n));}}}

Sane মূল কোড:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.Random;
import javax.swing.JFrame;

public class Paint {

    static int minSize = 1;
    static int startSize = 25;
    static double shrink = 0.1;
    static int branch = 50;
    static int treeCount = 75;

    static Random rand = new Random();
    static BufferedImage img;

    public static void main(String[] args) {
        img = new BufferedImage(800,600,BufferedImage.TYPE_INT_ARGB);
        forest(img);
        dither(img);
        new JFrame() {
            public void paint(Graphics g) {
                setSize(800,600);
                g.drawImage(img,0,0,null);
            }
        }.show();
    }

    static void forest(BufferedImage img){
        Graphics g = img.getGraphics();
        for(int i=0;i<treeCount;i++){
            int c = 255-(int)((double)i/treeCount*256);
            g.setColor(new Color(c,c,c));
            tree(g,rand.nextInt(800), 599, startSize+(rand.nextInt(21-10)), rand.nextInt(7)-3);
        }
    }

    static void tree(Graphics g, double x, double y, double scale, double angle){
        if(scale < minSize)
            return;
        g.fillOval((int)(x-scale/2), (int)(y-scale/2), (int)scale, (int)scale);
        scale -= shrink;
        int count = rand.nextInt(branch)==0?2:1;
        for(int i=0;i<count;i++){
            double newAngle = angle + rand.nextDouble()-0.5;
            if(newAngle < -15) newAngle = -15;
            if(newAngle > 15) newAngle = 15;
            double nx = x + (scale/2)*Math.cos(newAngle);
            double ny = y - (scale/2)*Math.sin(newAngle);
            tree(g, nx, ny, scale, newAngle);
        }
    }

    static void dither(BufferedImage img) {
        for (int i=0;i<800;i++)
            for (int j=0;j<600;j++) {
                double lum = ((img.getRGB(i, j) >>> 16) & 0xFF) / 255d;
                if (lum <= threshold[rand.nextInt(threshold.length)]-0.2)
                    img.setRGB(i, j, 0xFF000000);
                else
                    img.setRGB(i, j, 0xFFFFFFFF);
            }
    }

    static double[] threshold = { 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31,
            0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42,
            0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53,
            0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6, 0.61, 0.62, 0.63, 0.64,
            0.65, 0.66, 0.67, 0.68, 0.69 };

}

আরো একটা? ঠিক আছে! এই একটিকে কিছুটা নিচে নামিয়ে দেওয়া হয়েছে, যাতে সামনের কৃষ্ণাঙ্গগুলি অনেক চাটুকার হয়।

দুর্ভাগ্যক্রমে, দ্রাক্ষালতা দ্রাক্ষালতা স্তরগুলির সূক্ষ্ম বিবরণ প্রদর্শন করে না। এখানে কেবল তুলনার জন্য একটি গ্রেস্কেল সংস্করণ:

Comments

খুশী হলাম। খুশী আমার কোডটি সহায়ক হয়েছিল;)

— অ্যাভারোয়েস

আমি বিধিবিধানে কোথাও পড়ি নি যে দিশেহারা হওয়া দরকার। আমি মনে করি শিরোনামহীন সংস্করণটি আরও সুন্দর দেখাচ্ছে।

— লার্স এবার্ট

@ লার্স দেরী করার দরকার নেই, তবে: কেবল কালো এবং সাদা ব্যবহার করা যেতে পারে, ধূসর মানের কোনও মূল্য নেই ...

— ম্যানুয়েল ক্যাসটেন

Answer 3

জাভাস্ক্রিপ্ট + এইচটিএমএল - গল্ফ করা হয়নি

@ ম্যানুয়েল ক্যানস্টেনের অ্যালগরিদমের একটি জাভাস্ক্রিপ্ট পোর্টিং - এই গাছগুলি দেখতে কত দুর্দান্ত লাগছে তা আশ্চর্য।

কিছু আলাদা করার জন্য, আমি চিত্রটি রঙে আঁকি, তারপরে শেষ ধাপে b / w তে যাই।

কেন জানি না, তবে আমার বন কম অন্ধকার এবং ম্যানুয়ালের প্রতি ভীতিজনক শ্রদ্ধা।

জেএসফিডেলের সাথে পরীক্ষা করুন বা নীচে নতুন স্নিপেট চালান । এটি দ্রুত নয়। ধৈর্য ধরুন এবং বন জন্মানো দেখুন।

W=800
H=600
canvas.width = W;
canvas.height = H;

var ctx = canvas.getContext("2d");

R=function(m) { return m * Math.random()};
RAD=function(deg) { return deg / 180 * Math.PI};
LIMIT=function(x, min, max) {return x < min ? min : x > max ? max : x};
var SPEED = 0.01, HEIGHT = 11.0;

// Ground
var grd = ctx.createLinearGradient(0,0,0,H);
grd.addColorStop(0,"#88ccff");
grd.addColorStop(0.45,"#ffffee");
grd.addColorStop(0.5,"#80cc80");
grd.addColorStop(1,"#001100");
ctx.fillStyle = grd;
ctx.fillRect(0,0, W,H);


Plot = function(dist, side, h, s, alpha, diam)
{
    var x, y, a1,a2,scale = H/4 * 3.5 / dist, 
        x0 = side * scale + s * scale + W/2,
        y0 = H/2 + 2.5*scale - h*scale;
    
    k = dist
    if (diam > 0.05) {
        red = k*3|0;     
        green = k|0;
        a1=alpha+1
        a2=alpha-1
    }
    else
    {
        green= 80+(1-diam)*k*2|0;
        red = k|0;
        a1=0;
        a2=2*Math.PI;
    }
    diam *= scale;
    h *= scale;
    s *= scale;
    ctx.beginPath();
    ctx.arc(x0,y0,diam/2, a1,a2);//lpha-1, alpha+1);//0,2*Math.PI);
    ctx.fillStyle = 'rgb('+red+','+green+',0)';
    ctx.fill();
}

Grow = function(dist, side, h, s, alpha, grown)
{
    var diam, branchLength = 0.0;
    diam = (1.0 - grown / HEIGHT) * 0.5;
    do
    {
        alpha += R(RAD(3)) - RAD(1.5);
        h += Math.sin(alpha) * SPEED;
        s += Math.cos(alpha) * SPEED;
        branchLength += SPEED;
        grown += SPEED;
        diam = (1.0 - grown / HEIGHT) * 0.5;
        Plot(dist, side, h, s, alpha, diam);
    } while(branchLength < 5 * diam + R(6 * diam) && diam > 0.02);

    if (diam > 0.02)
    {
        var br = 0;

        if(R(10) > 2) br++,Grow(dist, side, h, s, alpha + RAD(15) + R(RAD(20)), grown);
        if(R(10) > 2) br++,Grow(dist, side, h, s, alpha - RAD(15) - R(RAD(20)), grown);
        if(R(10) < 2 || br == 0) Grow(dist, side, h, s, alpha - RAD(2.5) + R(RAD(5)), grown);
    }
}

trees=[]
for(i = 0; i < 300; ++i) trees.push({ z: 1+R(70), s:R(120)-60 });
trees.sort( function (a,b) { return a.z - b.z} );

Draw = function()
{
    t = trees.pop();
    if (t)
    {
        Grow(t.z, t.s, 0, 0, RAD(90), 0);
        setTimeout(Draw, 100);
    }
    else 
    {
        var e,c,d,p,i,l, img = ctx.getImageData(0,0,W,H);
        l = img.data.length;
        for (i = 0; i < l-W*4-4; i+=4)
        {
            c = (img.data[i]+img.data[i+1])/2|0
            c = img.data[i]
            d = c > 120 + R(16) ? 255 : 0
            e = c - d;
            img.data[i]=img.data[i+1]=img.data[i+2]=d
            c = (img.data[i+4]+img.data[i+5])/2|0
            
            c = LIMIT(c + ((e*7)>>4),0,255)
            img.data[i+4]=img.data[i+5]=img.data[i+6]=c
            p = i+W*4
            c = (img.data[p-4]+img.data[p-3])/2|0
            c = LIMIT(c + ((e*3)>>4),0,255)
            img.data[p-4]=img.data[p-3]=img.data[p-2]=c
            c = (img.data[p]+img.data[p+1])/2|0
            c = LIMIT(c+ ((e*5)>>4),0,255)
            img.data[p]=img.data[p+1]=img.data[p+2]=c
            c = (img.data[p+4]+img.data[p+5]*2)/3|0
            c = LIMIT(c + (e>>4),0,255)
            img.data[p+4]=img.data[p+5]=img.data[p+6]=c
    
        }
        bwcanvas.width = W;
        bwcanvas.height = H;
        var bwx = bwcanvas.getContext("2d");
        bwx.putImageData(img,0,0);
    }
}

setTimeout(Draw, 10);

<canvas id='bwcanvas'  width="2" height="2"></canvas>
<canvas id='canvas'  width="2" height="2"></canvas>

Comments

এটা স্থল, আমি মনে করি। ম্যানুয়েল গাছগুলি মাটিতে মিশ্রিত করে, একটি আচ্ছন্ন, ন্যূনতম চেহারা তৈরি করে। আপনার স্থল বিমানটি হালকা, উচ্চতর বৈসাদৃশ্য সহ আরও বাতাসময় চেহারা দেয়। এছাড়াও, ম্যানুয়েলের ছবিগুলিতে দৃ -় বর্ণের আকাশ এবং দূরত্ব বিবর্ণ হওয়া অস্পষ্ট কুয়াশা বা কুঁচকির চেহারা তৈরি করতে সহায়তা করে। (মনে রাখবেন, আমি আপনার ছবিগুলির চেয়ে ভিন্ন রূপ পছন্দ করি))

— ইলমারি করোনেন

হ্যাঁ, এটি ম্যানুয়েলের গভীর বনের জন্য একটি বাগান।

— শ্যাডট্যালকার

Answer 4

প্রসঙ্গ ফ্রি আর্ট 3 (1133)

সিএফ হ'ল ভেক্টর গ্রাফিক্স রেন্ডারিং ল্যাঙ্গুয়েজ, তাই আমি অ্যান্টি-এলাইজিং এড়াতে পারি না। আমি প্রায় একই জায়গায় বেশ কয়েকবার (পরিবর্তনশীল N) স্কোয়ার অঙ্কন করে কাজ করেছি । কুয়াশা এলোমেলো জায়গায় ছোট স্কোয়ার অঙ্কন করে করা হয়।

startshape main

W = 80*0.6
H = 60*0.6

N = 3

CF::Background = [ b -1 ]
CF::Size = [ x 0 y -20 s W H ]
CF::Color = 0
CF::ColorDepth = 16
CF::MinimumSize = 0.6

shape main {
  transform [ z 0 y (H/2) b 1 ]
  loop 30 [ z -1 y -2 ] {
    loop 200000 []
      SQUARE1 [ s (0.1/3) x -W..W y -H..H z -0.5..0.5 ]
  }

  transform [ b -1 z 3 ]
  loop 14 [[ s 1.1 y -0.8..-1 s 0.6 z -3 ]] {
    loop 14 [] tree [ x (-30..-20) z (-3..3) ]
    loop 14 [] tree [ x (20..30) z (-3..3) ]
  }
}

shape tree {
  branch [ ]
}

shape branch
rule 7 {
  transform [ s (1..2) 1]
  SQUARE1 [ ]

  branch [ y (0.2..0.3) x (-0.05..0.05) s 0.994 r (-6..6) z (-0.3..0.3)  ]
  branch1 [ b 0.001 z -2 r -20..20 ]
}
rule 0.001 { }
rule 0.3 { branch [ r 4..20 ] }
rule 0.3 { branch [ r -4..-20 ] }

shape branch1
rule 90 { }
rule { branch [ r -22..22 s 0.8..1 ] }

path SQUARE1 {
  MOVETO( 0.5,  0.5)
  LINETO(-0.5,  0.5)
  LINETO(-0.5, -0.5)
  LINETO( 0.5, -0.5)
  CLOSEPOLY()
  loop N [] FILL()[]
}

shape S {
  SQUARE [ a -1 ]
  loop 1000 [ ] SQUARE [ x (-0.5..0.5) y (-0.5..0.5) s 0.01..0.001 ]
}

বিভিন্ন নম্বর ব্যবহার করে আরও রেন্ডার দেয়

Comments

আমি পেয়েছি যে কোনও দুরন্ত বিকল্প নেই, তবে আউটপুটটি কেবল কালো / সাদা হতে হবে।

— Geobits

আপনি কি আর কোনও পথ খুঁজে পাচ্ছেন না? যেমনটি, এটি বৈধ উত্তর নয়।

— edc65

আপনাকে ঘোরাফেরা করতে হবে না, তবে আপনাকে কেবল 2 টি রঙ - কালো এবং সাদা ব্যবহার করতে হবে। গ্রেস্কেল ব্যবহার নিয়মের সাথে মেলে না। অস্পষ্টতা দূর করতে প্রশ্নটি সম্পাদনা করা হয়েছে। আমি এটি অর্জনের জন্য কিছু পদ্ধতি ব্যবহার করার পরামর্শ দিচ্ছি, যদিও দিশেহারা হোক বা না হোক, যাতে আরও অনেক ডাউনভোট আসার আগে আপনি নিজের উত্তরটি সম্পাদনা করতে পারেন।

— ট্রাইকোপলাক্স

ঠিক যেমনটি এটি সহায়তা করে: আপনি কালো এবং সাদা চিত্র অর্জনের জন্য স্বচ্ছ আয়তক্ষেত্রের আপনার বর্তমান পদ্ধতির ব্যবহার করতে পারেন, কেবলমাত্র আংশিক স্বচ্ছতার পরিবর্তে, কোনও ধরণের গ্রিড প্যাটার্নে সম্পূর্ণ স্বচ্ছতা ব্যবহার করুন, যাতে কেবলমাত্র প্রতিটি অন্যান্য গ্রিড সেল স্বচ্ছ।

— ট্রাইকোপল্যাক্স

এটি এখন প্রশ্নের চেতনায় থাকার খুব কাছাকাছি।

— ট্রাইকোপলাক্স

Answer 5

সি: 301

এই প্রোগ্রামটি পিজিএম ফর্ম্যাটে একটি সাধারণ, বিমূর্ত চিত্র তৈরি করে। আপনি এটি জিআইএমপি দিয়ে খুলতে পারেন।

int x,y,i,d,w;srand(time(NULL));unsigned char p[480000];FILE *f=fopen("a.pgm","w");fprintf(f,"P5\n800 600\n1\n");i=480000;while(i--)p[i]=i>240000|(i%800+i/800&3)!=0;i=100;while(i--){d=(11000-i*i)/99;y=300+1100/d;x=rand()%800;while(y--){w=300/d;while(w--)p[y*800+w+x]=0;}}fwrite(p, 1, 480000, f);fclose(f);

এখানে একটি উদাহরণ রান করুন:

Comments

এটি বন থেকে বারকোডের মতো দেখতে আরও বেশি :)

— সিলেস্টার

উল্টে বার্ট্রি অরণ্য

— ফ্যাব্রিকিও

স্ক্রোল ডাউন করার সময় আমি ভেবেছিলাম আমার ব্রাউজারটি চিত্রটি সঠিকভাবে রেন্ড করতে ব্যর্থ হয়েছে। বারকোড স্ক্যানারের সাহায্যে আপনার বার্টরিগুলি স্ক্যান করে যদি এই চ্যালেঞ্জটির URL দেয় তবে আমি আপনাকে এক টন বোনাস পয়েন্ট দেব। এটি বাদ দিয়ে এলোমেলো বন হবে না।

— nwp

আমি এটি স্ক্যান করেছি এবং আমার বারকোড স্ক্যানার আমাকে অভিশপ্ত করেছে। ধন্যবাদ.

— প্লাজমাএইচএইচ

@nwp আপনি কোনও ইউপিসি ডাটাবেস থেকে এলোমেলো কোড ধরতে পারেন । স্ক্যানেবল এখনও এলোমেলো :)

— Geobits

Answer 6

জাভা সহ আইএফএস

এই দ্রবণটি একটি (প্রোটো) গাছ বর্ণনা করার জন্য একটি আইট্রেটেড ফাংশন সিস্টেম (আইএফএস) ব্যবহার করে। আইএফএস 100 বার প্রয়োগ করা হয় (= বন)। প্রতিটি গাছ আঁকার আগে (বনে লাগানো) আইএফএসের জায়গায় কিছুটা পরিবর্তন করা হয় (এলোমেলো হাঁটার শৈলী)। তাই প্রতিটি গাছ দেখতে কিছুটা আলাদা লাগে।

ছবিগুলি এলোমেলো বীজ থেকে প্রাপ্ত:

• -824737443
• -1220897877
• -644492215
• 1133984583

কোনও দিশেহারা হওয়ার দরকার নেই।

import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.Random;
import javax.swing.*;

public class IFS {
    static Random random=new Random();
    static int BLACK = 0xff000000;
    static int treeCount = 100;
    static Random rand = new Random();
    static int Height = 600;
    static int Width = 800;
    static BufferedImage img = new BufferedImage(Width, Height, BufferedImage.TYPE_INT_ARGB);

    static double[][] ifs=new double[][] {//Tree 3 {; Paul Bourke  http://ecademy.agnesscott.edu/~lriddle/ifskit/gallery/bourke/bourke.ifs
       {0.050000,  0.000000,  0.000000,  0.600000,  0.000000,  0.000000,  0.028000},
       {0.050000,  0.000000,  0.000000, -0.500000,  0.000000,  1.000000,  0.023256},
       {0.459627, -0.321394,  0.385673,  0.383022,  0.000000,  0.600000,  0.279070},
       {0.469846, -0.153909,  0.171010,  0.422862,  0.000000,  1.100000,  0.209302},
       {0.433013,  0.275000, -0.250000,  0.476314,  0.000000,  1.000000,  0.555814 /*Paul Bourke has: 0.255814*/},
       {0.421325,  0.257115, -0.353533,  0.306418,  0.000000,  0.700000,  0.304651 /*Paul Bourke has: 0.204651*/},
    };

    public static void main(String[] args) {
        int seed=random.nextInt();
        //seed=-1220897877;
        random=new Random(seed);
        for (int t = 0; t < treeCount; t++) {
            for (int i = 0; i < ifs.length; i++) {
                for (int j = 0; j < ifs[0].length; j++) {
                    ifs[i][j]=R(ifs[i][j]);
                }
            }
            tree(random.nextDouble(), 0.1*random.nextDouble());
        }
        JFrame frame = new JFrame(""+seed) {
            public void paint(Graphics g) {
                setSize(800,600);
                g.drawImage(img,0,0,null);
            }
        };
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    private static void tree(double x0, double dist) {
        double y0=Math.atan(dist+0.01);
        double scale=Math.atan(0.01)/y0;
        double x=0;
        double y=0;
        for (int n = 0; n < 200000/Math.pow(20*dist+1, 8); n++) {
            int k = select(ifs);
            double newx=ifs[k][0]*x + ifs[k][1]*y + ifs[k][2];
            double newy=ifs[k][3]*x + ifs[k][4]*y + ifs[k][5];
            x=newx;
            y=newy;
            newx= Width*(0.5*scale*newx+x0);
            newy= Height*((1-0.5*scale*newy)-y0-0.1);
            if (0<=newx && newx<Width && 0<=newy && newy<Height) {
                img.setRGB((int)newx, (int)newy, BLACK);
            }
        }
    }

    private static double R(double x) {
        return (1+ 0.01*random.nextGaussian())*x;
    }

    private static int select(double[][] ifs) {
        int k;
        double sum=0;
        for(k=0; k<ifs.length; k++) {
            sum+=ifs[k][6];
        }
        double r=sum*random.nextDouble();
        sum=ifs[0][6];
        for(k=0; k<ifs.length-1 && r>sum; k++) {
            sum+=ifs[k+1][6];
        }
        return k;
    }
}

Comments

শেষ চিত্রগুলি সেরা দেখাচ্ছে। তবে আমি মনে করি আপনার কম গাছ চেষ্টা করা উচিত, কারণ এখন সর্বদা কালো অজ্ঞাতনামা অঞ্চল রয়েছে তবে কিনারাগুলি এটি আরও ভাল দেখাচ্ছে।

— সোমনিয়াম

"সৌন্দর্য দর্শকের চোখে পড়ে।" আমি প্রচুর প্রকরণের পরীক্ষা করেছি। শেষে, আমি ট্রিকাউন্ট = 100 নিয়ে এসেছি। আমার সমাধান অনুলিপি এবং পরিবর্তন করতে অন্য সবাই স্বাগত।

— বব জেনোম

Answer 7

আমি এখানে কনফিফারের স্বতন্ত্র অভাব লক্ষ্য করেছি, তাই আমি পাইথনে একসাথে কিছু হ্যাক করেছি।

from PIL import Image
import random

#Generates the seed for a tree
def makeSeed(y):
    random.seed()
    seed_x = random.randint(10, 590)
    seed_y = y
    width = random.randint(5, 10)
    height = random.randint(width*5, width*30)

    return (seed_x, seed_y, width, height)

#Grows the vertical components
def growStems(seed_data, pixel_field):
    seed_x = seed_data[0]
    seed_y = seed_data[1]
    width = seed_data[2]
    height = seed_data[3]
    for x in range(seed_x, seed_x+width):
        for y in range(seed_y-height, seed_y):
            pixel_field[x][y] = (0, 0, 0)
            #Dithering
            if seed_y > 300 and seed_y < 320:
                if (x+y)%2==0:
                    pixel_field[x][y] = (255, 255, 255)
            elif seed_y >= 320 and seed_y < 340:
                if (x+y)%4==0:
                    pixel_field[x][y] = (255, 255, 255)
            elif seed_y >= 340 and seed_y < 360:
                if (x+y)%8==0:
                    pixel_field[x][y] = (255, 255, 255)

    return pixel_field

#Grows the horizontal components
def growBranches(seed_data, pixel_field):
    seed_x = seed_data[0]
    seed_y = seed_data[1]
    width = seed_data[2]
    height = seed_data[3]
    branch_height = seed_y-height
    branch_width = width
    branch_length = 2
    max_prev = branch_length
    branches = []
    while(branch_height >= seed_y-height and branch_height < seed_y-(3*width) and branch_length < height/3):
        branches.append((branch_height, branch_width, branch_length))
        branch_height+= 4
        branch_length+=2
        #Gives the conifer unevenness to make it look more organic
        if random.randint(0,110) > 100 and branch_length > max_prev:
            max_prev = branch_length
            branch_length -= branch_length/4
    max_length = height/3


    for x in range(seed_x-max_length, seed_x+max_length):
        for y in range(seed_y-height, seed_y):
            for branch in branches:
                bh = branch[0]
                bw = branch[1]
                bl = branch[2]
                #Establishing whether a point is "in" a branch
                if x >= seed_x-bl+(width/2) and x <= seed_x+bl+(width/2):
                    if x > 1 and x < 599:
                        if y >= bh-(bw/2) and y <= bh+(bw/2):
                            if y < 400 and y > 0:
                                pixel_field[x][y] = (0, 0, 0)
                                #Dithering
                                if seed_y > 300 and seed_y < 320:
                                    if (x+y)%2==0:
                                        pixel_field[x][y] = (255, 255, 255)
                                elif seed_y >= 320 and seed_y < 340:
                                    if (x+y)%4==0:
                                        pixel_field[x][y] = (255, 255, 255)
                                elif seed_y >= 340 and seed_y < 360:
                                    if (x+y)%8==0:
                                        pixel_field[x][y] = (255, 255, 255)

    return pixel_field


def growTrees(n):
    pixel_field = [[(255, 255, 255) for y in range(400)] for x in range(600)]
    #Create the ground
    for i in range(600):    
        for j in range(400):
            if pixel_field[i][j]==(255,255,255) and j > 300:
                if (i+j)%2 == 0:
                    pixel_field[i][j]=(0,0,0)
    seed_ys=[]
    #Generates seeds for the trees and orders them back to front to make the dithering work
    for t in range(n):
        seed_ys.append(random.randint(300,390))
    seed_ys.sort()

    for s in range(len(seed_ys)):
        seed= makeSeed(seed_ys[s])
        pixel_field = growStems(seed, pixel_field)
        pixel_field = growBranches(seed, pixel_field)
    return pixel_field

def makeForest():
    forest = growTrees(25)
    img = Image.new( 'RGB', (600,400), "white") # create a new black image
    pixels = img.load() # create the pixel map
    for i in range(img.size[0]):    # for every pixel:
        for j in range(img.size[1]):
            if pixels[i,j]==(255,255,255) and j > 300:
                if (i+j)%2 == 0:
                    pixels[i,j]=(0,0,0)
            pixels[i,j] = forest[i][j] # set the colour accordingly

    img.save("Forest25.jpg")

if __name__ == '__main__':
    makeForest()

এটি আমার প্রথম কোড গল্ফ ছিল, খুব মজা লাগছিল!

Comments

ভাল লাগছে! আমি এটা পছন্দ করি.

— টনিসনিপার

Answer 8

এই উত্তরটি আমি যতটা আশা করেছিলাম ততটা সুন্দর নয়, তবে আমি কাজ করছি এমন আরও 3 ডি ধারণার জন্য এটি একটি পাথর পাথর এবং আমি কোন গাছগুলি সংস্থান লাভ করে বাস্তবে অনুকরণের ধারণাটি পছন্দ করি

package forest;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Forest extends Canvas{
    private int[] heights = new int[800];
    private BufferedImage buffered_image;
    File outputFile = new File("saved.png");
    Random r = new Random();
    public Forest() {
        buffered_image = new BufferedImage(800, 600,
                BufferedImage.TYPE_INT_RGB);
        for( int j = 0; j < 800; j++){
            heights[j] = -10000;
            for(int k = 0; k < 600; k++){
                buffered_image.setRGB(j, k, 0xFFFFFF);
            }
        }
        for(int i = 0; i < 7; i ++){
            heights[r.nextInt(800)] = 0;
        }

        this.setPreferredSize(new Dimension(800, 600));
        this.setSize(new Dimension(800, 600));
        for( int i = 0; i < 200000; i++){
            int x = r.nextInt(798) + 1;
            heights[x] =  Math.min(599, heights[x - 1] == heights[x + 1] ? heights[x] : Math.max(Math.max(heights[x - 1], heights[x]),heights[x + 1]) + 1);
            buffered_image.setRGB(x, Math.min(599, 600 - heights[x]), 0);
        } 

        try {

            ImageIO.write(buffered_image, "png", outputFile);
        } catch (IOException e) {

        }
        update();
    }
    public void repaint(){
        if(this.getGraphics() != null)
        paint(this.getGraphics());
    }


    public void paint(Graphics g) {
        g.drawImage(buffered_image, 0, 0, this);
    }

    public void update() {  
        repaint();
    }

    public static void main(String[] args) throws IOException {
        JFrame main_frame = new JFrame();
        main_frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel top_panel = new JPanel();
        top_panel.setLayout(new BorderLayout());
        Forest s = new Forest();
        top_panel.add(s, BorderLayout.CENTER);
        main_frame.setContentPane(top_panel);

        main_frame.pack();
        main_frame.setVisible(true);
    }

}

Comments

এটিকে ফার-গাছের সাথে সাদৃশ্যপূর্ণ করতে সম্ভবত এটি উল্লম্বভাবে ফ্লিপ করবেন?

— সোমনিয়াম