Fractal tree: Difference between revisions

{{trans|Nim}}

 

Width = 1000

Height = 1000

DeltaAngle = 0.2 * math:pi

 

I len >= 1

V x2 = x + len * cos(theta)

drawTree(outfile, x2, y2, len * ScaleFactor, theta - DeltaAngle)

 

outsvg.write(|‘<?xml version='1.0' encoding='utf-8' standalone='no'?>

<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>

’)

drawTree(outsvg, 0.5 * Width, Height, TrunkLength, StartingAngle)

 

=={{header|Action!}}==

Action! language does not support recursion. Therefore an iterative approach with a stack has been proposed.

 

INT ARRAY SinTab=[

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Fractal_tree.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{libheader|SDLAda}}

 

with SDL.Video.Windows.Makers;

Window.Finalize;

SDL.Finalise;

 

=={{header|Arturo}}==

 

height: 1000

 

'svg ++ "</svg>"

 

 

{{out}}

[http://i.imgur.com/H7iJOde.png Image] - Link, since uploads seem to be disabled currently.

{{libheader|GDIP}}

#NoEnv

SetBatchLines, -1

Exit:

Gdip_Shutdown(pToken)

 

=={{header|BASIC}}==

==={{header|BASIC256}}===

[[File:Fractal tree BASIC-256.png|thumb|right|Asymmetric fractal tree image created by the BASIC-256 script]]

 

level = 12 : len =63 # initial values

line x,y,xn,yn

x = xn : y = yn

 

==={{header|Run BASIC}}===

'from BASIC256 - http://rosettacode.org/wiki/Fractal_tree#BASIC256

'copy this text and go to http://www.runbasic.com

return

'end of code

 

==={{header|BBC BASIC}}===

 

{{works with|BBC BASIC for Windows}}

Spread = 25

Scale = 0.76

SizeY% = 300

Depth% = 10

VDU 23,22,SizeX%;SizeY%;8,16,16,128

PROCbranch(x2, y2, size * Scale, angle + Spread, depth% - 1)

ENDIF

 

==={{header|IS-BASIC}}===

110 OPTION ANGLE DEGREES

120 GRAPHICS HIRES 2

210 CALL TREE(N*.75)

220 PLOT RIGHT 25,BACK N,

 

=={{header|C}}==

 

{{libheader|SGE}} or {{libheader|cairo}}

#ifdef WITH_CAIRO

#include <cairo.h>

#include <math.h>

 

#endif

#define SIZE 800 // determines size of window

#define SCALE 5 // determines how quickly branches shrink (higher value means faster shrinking)

0.0, -1.0,

INITIAL_LENGTH,

BRANCHES);

SDL_UpdateRect(surface, 0, 0, 0, 0);

SDL_Quit();

return 0;

 

=={{header|C++}}==

[[File:fracTree_cpp.png|320px]]

#include <windows.h>

#include <string>

 

//--------------------------------------------------------------------------------------------------

 

//--------------------------------------------------------------------------------------------------

public:

fractalTree() { _ang = DegToRadian( 24.0f ); }

 

void create( myBitmap* bmp )

}

//--------------------------------------------------------------------------------------------------

 

=={{header|Ceylon}}==

{{libheader|Swing}} {{libheader|AWT}}

Be sure to import java.desktop and ceylon.numeric in your module.ceylon file.

 

JFrame { exitOnClose }

fractalTree.visible = true;

 

=={{header|Clojure}}==

{{trans|Java}}

{{libheader|Swing}} {{libheader|AWT}}

'javax.swing.JFrame)

 

(.show)))

 

 

=={{header|Common Lisp}}==

{{libheader|lispbuilder-sdl}}

{{trans|Clojure}}

 

(defun deg-to-radian (deg)

(fractal-tree 9)

 

=={{header|D}}==

===SVG Version===

{{trans|Raku}}

 

enum width = 1000, height = 1000; // Image dimension.

tree(width / 2.0, height, length, 3 * PI / 2);

"</svg>".writeln;

 

===Turtle Version===

This uses the turtle module from the Dragon Curve task, and the module from the Grayscale Image task.

{{trans|Logo}}

 

void tree(Color)(Image!Color img, ref Turtle t, in uint depth,

img.tree(t, 10, 80, 0.7, 30);

img.savePGM("fractal_tree.pgm");

 

===Alternative version===

{{trans|Java}}

Using DFL.

import std.math;

 

}

return result;

 

=={{header|EasyLang}}==

 

 

#

.

on timer

 

=={{header|F_Sharp|F#}}==

{{trans|Raku}}

 

let (width, height) = 1000., 1000. // image dimension

xmlns='http://www.w3.org/2000/svg'>"

tree (width/2.) height length (3.*pi/2.)

 

=={{header|Fantom}}==

using fwt

using gfx

}

}

 

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

' compile with: fbc -s gui

 

windowtitle ("Fractal Tree, hit any key to end program")

Sleep

 

=={{header|Frege}}==

{{Works with|Frege|3.23.888-g4e22ab6}}

 

 

import Java.IO

drawTree g t 16

f <- File.new "FractalTreeFrege.png"

 

Output is [http://funwithsoftware.org/images/2016-FractalTreeFrege.png here] due to [[User talk:Short Circuit#Is file uploading blocked forever?|Is file uploading blocked forever?]]

 

=={{header|Frink}}==

// Draw Fractal Tree in Frink

 

// Show the final tree

g.show[]

 

=={{header|Go}}==

[[file:GoFtree.png|right|thumb|png converted from output ppm]]

 

// Files required to build supporting package raster are found in:

ftree(g, x2, y2, distance*frac, direction+angle, depth-1)

}

 

=={{header|Haskell}}==

An elegant yet universal monoidal solution.

{{libheader|Gloss}}

 

type Model = [Picture -> Picture]

, Translate 0 100 . Scale 0.5 0.5 . Rotate (-30) ]

 

 

The solution gives rise to a variety of fractal geometric structures. Each one can be used by substituting <code>tree1</code> in the <code>main</code> function by the desired one.

tree2 t = fractal 8 branches $ Line [(0,0),(0,100)]

where branches = [ Translate 0 100 . Scale 0.75 0.75 . Rotate t

pentagon = Line [ (sin a, cos a) | a <- [0,2*pi/5..2*pi] ]

x = 2*cos(pi/5)

 

'''Alternative solution'''

{{libheader|HGL}}

 

import Graphics.HGL.Run

import Control.Arrow

(\w -> setGraphic w (overGraphics ( map polyline $ pts (n-1))) >> getKey w)

 

 

=={{header|Icon}} and {{header|Unicon}}==

WOpen("size=800,600", "bg=black", "fg=white") | stop("*** cannot open window")

drawtree(400,500,-90,9)

}

return

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

 

L0=: 50 NB. initial length

A0=: 1r8p1 NB. initial angle: pi divided by 8

dA=: 0.75 NB. shrink factor for angle

N=: 14 NB. number of branches

L=: L0*dL^1+i.N NB. lengths of line segments

NB. relative angles of successive line segments

A=: A0*(dA^i.N) +/\@:*("1) _1 ^ #:i.2 ^ N

NB. end points for each line segment

P=: 0 0+/\@,"2 +.*.inv (L0,0),"2 L,"0"1 A

wd {{)n

pc P closeok;

setp wh 480 640;

pshow;

 

See the [[Talk:Fractal tree#J Explanation|talk page]] for some implementation notes.

=={{header|Java}}==

{{libheader|Swing}} {{libheader|AWT}}

import java.awt.Graphics;

import javax.swing.JFrame;

new FractalTree().setVisible(true);

}

 

=={{header|JavaScript}}==

Implementation using HTML5 canvas element to draw tree structure.

<body>

<canvas id="canvas" width="600" height="500"></canvas>

 

</body>

 

=={{header|jq}}==

The following generates SVG, which can be viewed by following the link below.

# len defines the trunk size;

# scale defines the branch length relative to the trunk;

;

 

{{out}}

$ jq -r -n -r -f Fractal_tree_svg.jq > Fractal_tree.svg

=={{header|Julia}}==

{{trans|F#}}

const width = height = 1000.0

const trunklength = 400.0

 

write(outsvg, "</svg>\n") # view file tree.svg in browser

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.Color

fun main(args: Array<String>) {

FractalTree().isVisible = true

 

=={{header|Lambdatalk}}==

1) defining the function tree:

 

 

The complete ouput can be seen displayed in http://lambdaway.free.fr/lambdawalks/?view=fractal_tree

 

=={{header|Liberty BASIC}}==

LB includes Logo-type turtle commands, so can be drawn that way as well as that shown here.

NoMainWin

sw = 640 : sh = 480

End If

End Sub

 

=={{header|Lingo}}==

-- Creates an image of a fractal tree

-- @param {integer} width

_drawTree(img, x2, y2, angle+spreadAngle, depth-1, size*ScaleFactor, spreadAngle, scaleFactor)

end if

Usage:

initSize = 7.0

spreadAngle = 35*PI/180

scaleFactor = 0.95

 

=={{header|Logo}}==

if :depth=0 [stop]

setpensize round :depth/2

 

clearscreen

 

=={{header|Lua}}==

===Bitmap===

Needs L&Ouml;VE 2D Engine

g, angle = love.graphics, 26 * math.pi / 180

wid, hei = g.getWidth(), g.getHeight()

g.draw( canvas )

end

 

===ASCII===

Using the Bitmap class and text renderer from [[Bitmap/Bresenham%27s_line_algorithm#Lua|here]], then extending...

if depth <= 0 then return end

local fork, leng = forkfn(), lengfn()

bitmap:tree(192, 120, math.pi/2, 8, function() return 0.6 end, function() return 2.5 end)

bitmap:tree(320, 120, math.pi/2, 8, function() return 0.2+math.random()*0.3 end, function() return 2.0+math.random()*2.0 end)

{{out}}

Shown at 25% scale:

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

pt : {_, _}, \[Theta]orient_: \[Pi]/2, \[Theta]sep_: \[Pi]/9,

depth_Integer: 9] := Module[{pt2},

]

Graphics[fractalTree[{0, 0}, \[Pi]/2, \[Pi]/9]]

[[File:MathFractalTree.png]]

 

=={{header|NetRexx}}==

{{libheader|Swing}}

{{libheader|AWT}}

options replace format comments java crossref symbols binary

 

RFractalTree().setVisible(isTrue)

return

=={{header|Nim}}==

{{trans|Julia}}

import math

import strformat

outsvg.write("</svg>\n") # View file tree.svg in browser.

 

 

=={{header|OCaml}}==

{{libheader|ocaml-cairo}}

 

#load "bigarray.cma"

#load "cairo.cma"

 

Cairo_png.surface_write_to_file surf img_name

 

=={{header|PARI/GP}}==

{{Works with|PARI/GP|2.7.4 and above}}

 

\\ Fractal tree (w/recursion)

\\ 4/10/16 aev

FractalTree(15,1500); \\FracTree3.png

}

 

{{Output}}

=={{header|Perl}}==

using the [http://search.cpan.org/~lds/GD-2.45/GD/Simple.pm GD::Simple] module.

 

my ($width, $height) = (1000,1000); # image dimension

tree($x, $y, $len*$scale, $angle+35);

tree($x, $y, $len*$scale, $angle-35);

 

=={{header|Phix}}==

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/fractaltree.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\FractalTree.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PHP}}==

Image is created with GD module. Code adapted from the JavaScript version.

<?php

header("Content-type: image/png");

imagedestroy($img);

?>

 

=={{header|PicoLisp}}==

This uses the 'brez' line drawing function from

[[Bitmap/Bresenham's line algorithm#PicoLisp]].

 

(de fractalTree (Img X Y A D)

(prinl "P1")

(prinl 400 " " 300)

 

=={{header|Plain English}}==

Start up.

Clear the screen to the lightest blue color.

Turn left 1/16 of the way. Draw another tree given the size times 2/3. Turn right 1/16 of the way.

Turn right 1/16 of the way. Draw a third tree given the size times 2/3. Turn left 1/16 of the way.

{{out}}

[https://commons.wikimedia.org/wiki/File:Fractal-tree.png]

 

=={{header|PostScript}}==

%%BoundingBox: 0 0 300 300

%%EndComments

%

showpage origstate restore

 

%%BoundingBox: 0 0 300 300

/!0 { dup 1 sub dup 0 gt } def

 

/d 10 def 5 setlinewidth 1 setlinecap 170 20 translate d tree pop

 

=={{header|POV-Ray}}==

#include "transforms.inc"

 

union {

FractalTree(<-2,0,0>, <1,0,0>, 1, Spread_Ang, Branches)

 

=={{header|Prolog}}==

SWI-Prolog has a graphic interface : XPCE.

new(D, window('Fractal')),

send(D, size, size(800, 600)),

drawTree(D, X2, Y2, A2, De).

 

 

=={{header|PureBasic}}==

#Scaling_Factor = 0.75

#Deg_to_Rad = #PI / 180

EndIf

 

[[Image:PB_FractalTree.png]]

 

 

==== Using rotation ====

size(600, 600);

background(0);

popMatrix();

}

 

==== Calculating coordinates ====

{{trans|Python}}

 

size(600, 600);

background(0);

drawTree(x2, y2, angle + forkAngle, depth - 1);

}

 

==={{header|Processing Python mode}}===

{{trans|Processing}}

 

size(600, 600)

background(0)

rotate(2 * -fork_ang)

drawTree(0, 0, depth - 1)

 

==== Calculating coordinates ====

{{trans|Python}}

 

size(600, 600)

background(0)

line(x1, y1, x2, y2)

drawTree(x2, y2, angle - fork_angle, depth - 1)

 

=={{header|Python}}==

[[File:fractal-tree-python.png|right|thumb]]

{{libheader|pygame}}

 

pygame.init()

pygame.display.flip()

while True:

=={{header|QB64}}==

Const sw% = 640

Const sh% = 480

Call tree(newX, newY, initAngle + theta, theta, iL, iD)

End If

 

=={{header|Quackery}}==

 

[ [ 1 1

-v fly ] is tree ( n/d --> )

-1 4 turn

-450 1 fly

 

{{output}}

 

 

=={{header|R}}==

[[File:FRTR12.png|200px|right|thumb|Output FRTR12.png]]

[[File:FRTR15.png|200px|right|thumb|Output FRTR15.png]]

## Recursive FT plotting

plotftree <- function(x, y, a, d, c) {

pFractalTree(12,0.6,210);

pFractalTree(15,0.35,600);

{{Output}}

<pre>

=={{header|Racket}}==

[[File:tree-racket.png|right|thumb]]

#lang racket

(require graphics/turtles)

(tree 35)

(save-turtle-bitmap "tree.png" 'png)

 

=={{header|Raku}}==

(formerly Perl 6)

Image is created in [[wp:SVG|SVG]] format.

my $scale = 6/10; # branch scale relative to trunk

my $length = 400; # trunk size

tree($x2, $y2, $length*$scale, $angle + pi/5);

tree($x2, $y2, $length*$scale, $angle - pi/5);

 

=={{header|Red}}==

 

color: brown

]

ends: newends

{{out}}

[https://raw.githubusercontent.com/Palaing/redlib/master/games/images/fractaltree.png fractal tree image]

 

=={{header|Ring}}==

load "guilib.ring"

 

tree(self, x2, y2, size * scale, angle - spread, depth - 1)

tree(self, x2, y2, size * scale, angle + spread, depth - 1) ok}

Output:

 

=={{header|Ruby}}==

{{libheader|Shoes}}

background "#fff"

stroke "#000"

drawTree(300,550,-90,9)

 

=={{header|Rust}}==

{{libheader|Piston}}

// piston = "0.35.0"

// piston2d-graphics = "0.23.0"

}

}

 

=={{header|Scala}}==

Adapted from the Java version. Screenshot below.

import java.awt.{RenderingHints, BasicStroke, Color}

 

}

}

[[File:scalaTree.png]]

 

The tree is created as a list of line segments, which can then be drawn on a required device. For this program, the tree is output to an eps file.

 

(import (scheme base)

(scheme file)

 

(output-tree-as-eps "fractal.eps" (create-tree 400 200 90 9))

 

=={{header|Scilab}}==

This script uses complex numbers to represent (x,y) coordinates: real part as x position, and imaginary part as y position. The tree is generated using an L-system approach, and the lines are then drawn by interpreting the resulting sentence. The output is plotted onto graphic window.

 

ratio = 0.8; //size ratio between two consecutive branches

depth = 9; //final number of branch levels

plot2d(real(tree),imag(tree),14);

set(gca(),'isoview','on');

 

===Recursive approach===

{{trans|PHP}}

height = 512;

img=scf();

drawTree(width/2,height,90,10);

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

drawTree(300, 470, -90.0, 9);

ignore(getc(KEYBOARD));

 

Original source: [http://seed7.sourceforge.net/algorith/graphic.htm#fractree]

=={{header|Sidef}}==

{{trans|Perl}}

 

len < 1 && return()

tree(img, width/2, height)

 

 

=={{header|Smalltalk}}==

This example is coded for Squeak Smalltalk.

 

Object subclass: #FractalTree

instanceVariableNames: ''

poolDictionaries: ''

category: 'RosettaCode'

 

Methods for FractalTree class:

 

tree: aPoint length: aLength angle: anAngle

| p a |

self tree: 700@700 length: 200 angle: 0.

]

 

Now open a new Workspace and enter:

 

FractalTree new draw.

 

=={{header|SVG}}==

 

<div style="clear:both;"></div>

<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"

"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">

</g>

 

=={{header|Swift}}==

[http://i.imgur.com/F8Fyn1i.png Image] - Link, since uploads seem to be disabled currently.

In a playground:

func degrees_to_radians() -> CGFloat {

return CGFloat(M_PI) * self / 180.0

let tree = Tree(frame: CGRectMake(0, 0, 300, 300))

tree

 

=={{header|Standard ML}}==

Works with PolyML

open Motif;

 

end ;

 

 

=={{header|Tcl}}==

{{libheader|Tk}}

 

set SIZE 800

pack [canvas .c -width $SIZE -height $SIZE]

draw_tree .c [expr {$SIZE/2}] [expr {$SIZE-10}] 0.0 -1.0 $INITIAL_LENGTH \

 

=={{header|TUSCRIPT}}==

Image is created in SVG-format

$$ MODE TUSCRIPT

dest="fracaltree.svg"

WRITE/NEXT d "</svg>"

ENDACCESS d

 

=={{header|TypeScript}}==

{{trans|JavaScript}}

var canvas: HTMLCanvasElement = document.createElement('canvas')

canvas.width = 600

ctx.stroke()

 

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

import "math" for Math

}

 

 

=={{header|XPL0}}==

[[File:FtreeXPL0.png|200px|thumb|right|Output]]

 

proc DrawBranch(Lev, Dir, Len, X, Y);

if ChIn(1) then []; \wait for keystroke

SetVid(3); \restore normal text mode

 

=={{header|zkl}}==

{{trans|BBC BASIC}}{{trans|XPL0}}

[[File:FractalTree.zkl.jpg|250px|thumb|right]]

scale:=0.76;

sizeX:=400; sizeY:=300;

branch(sizeX,0,sizeY/2,90.0,10);

bitmap.write(File("foo.ppm","wb"));

The funkyness (pasteArgs) in the recursion (self.fcn) is due to the closure ('wrap): the closed over args are stashed in the arglist, they need to be added to the parameters when recursing.

 

=={{header|ZX Spectrum Basic}}==

{{trans|BASIC256}}

20 LET x=127: LET y=0

30 LET rotation=PI/2

1030 PLOT x,y: DRAW xn-x,y-yn

1040 LET x=xn: LET y=yn

 

[[Category:Geometry]]