Sunflower fractal

Go

Translation of: Ring

The image produced, when viewed with (for example) EOG, is similar to the Ring entry. <lang go>package main

import (

   "github.com/fogleman/gg"
   "math"

)

func main() {

   dc := gg.NewContext(400, 400)
   dc.SetRGB(1, 1, 1)
   dc.Clear()
   dc.SetRGB(0, 0, 1)
   c := (math.Sqrt(5) + 1) / 2
   numberOfSeeds := 3000
   for i := 0; i <= numberOfSeeds; i++ {
       fi := float64(i)
       fn := float64(numberOfSeeds)
       r := math.Pow(fi, c) / fn
       angle := 2 * math.Pi * c * fi
       x := r*math.Sin(angle) + 200
       y := r*math.Cos(angle) + 200
       fi /= fn / 5
       dc.DrawCircle(x, y, fi)
   }
   dc.SetLineWidth(1)
   dc.Stroke()
   dc.SavePNG("sunflower_fractal.png")

}</lang>

Microsoft Small Basic

Translation of: Ring

<lang smallbasic>' Sunflower fractal - 24/07/2018

 GraphicsWindow.Width=410
 GraphicsWindow.Height=400
 c=(Math.SquareRoot(5)+1)/2
 numberofseeds=3000
 For i=0 To numberofseeds
   r=Math.Power(i,c)/numberofseeds
   angle=2*Math.Pi*c*i
   x=r*Math.Sin(angle)+200
   y=r*Math.Cos(angle)+200
   GraphicsWindow.DrawEllipse(x, y, i/numberofseeds*10, i/numberofseeds*10)
 EndFor </lang>

Output:

Sunflower fractal

Perl

Translation of: Sidef

<lang perl>$seeds = 3500; $c = 1.25**0.5 + 0.53;

print qq{<svg width="400" height="400" style="stroke:gold"> <rect width="100%" height="100%" fill="black" />\n};

for $i (1..$seeds) {

       $r = ($i**$c) / $seeds;
       $t = 2 * 3.15159 * $c * $i;
       $x = $r * sin($t) + 200;
       $y = $r * cos($t) + 200;
       printf qq{<circle cx="%.2f" cy="%.2f" r="%.2f" />\n}, $x, $y, $i/(5*$seeds);
   }

print "</svg>\n";</lang>

Perl 6

Works with: Rakudo version 2018.06

This is not really a fractal. It is more accurately an example of a Fibonacci spiral or Phi-packing.

Or, to be completely accurate: It is a variation of a generative Fermat's spiral using the Vogel model to implement phi-packing. See: https://thatsmaths.com/2014/06/05/sunflowers-and-fibonacci-models-of-efficiency

<lang perl6>use SVG;

my $seeds = 3000; my @center = 300, 300; my $scale = 5;

constant \φ = (3 - 5.sqrt) / 2;

my @c = map {

   my ($x, $y) = ($scale * .sqrt) «*« |cis($_ * φ * τ).reals »+« @center;
   [ $x.round(.01), $y.round(.01), (.sqrt * $scale / 100).round(.1) ]

}, 1 .. $seeds;

say SVG.serialize(

   svg => [
       :600width, :600height, :style<stroke:yellow>,
       :rect[:width<100%>, :height<100%>, :fill<black>],
       |@c.map( { :circle[:cx(.[0]), :cy(.[1]), :r(.[2])] } ),
   ],

);</lang> See: Phi packing (SVG image)

Ring

Project : Sunflower fractal

load "guilib.ring"

paint = null

new qapp

       {
       win1 = new qwidget() {
                 setwindowtitle("Sunflower fractal")
                 setgeometry(100,100,320,500)
                 label1 = new qlabel(win1) {
                             setgeometry(10,10,400,400)
                             settext("")
                 }
                 new qpushbutton(win1) {
                         setgeometry(100,400,100,30)
                         settext("draw")
                         setclickevent("draw()")
                 }
                 show()
       }
       exec()
       }

func draw

       p1 = new qpicture()
              color = new qcolor() {
              setrgb(0,0,255,255)
       }
       pen = new qpen() {
                setcolor(color)
                setwidth(1)
       }
       paint = new qpainter() {
                 begin(p1)
                 setpen(pen)

       c = (sqrt(5) + 1) / 2
       numberofseeds = 3000
       for i = 0 to numberofseeds
             r = pow(i, c ) / (numberofseeds)
             angle = 2 * 3.14 * c * i
             x = r * sin(angle) + 100
             y = r * cos(angle) + 100
            drawellipse(x, y, i / (numberofseeds / 10), i / (numberofseeds / 10))
       next

       endpaint()
       }
       label1 { setpicture(p1) show() }

</lang> Output:

Sunflower fractal

Sidef

Translation of: Go

<lang ruby>require('Imager')

func draw_sunflower(seeds=3000) {

   var img = %O<Imager>.new(
       xsize => 400,
       ysize => 400,
   )

   var c = (sqrt(1.25) + 0.5)
   { |i|
       var r = (i**c / seeds)
       var θ = (2 * Num.pi * c * i)
       var x = (r * sin(θ) + 200)
       var y = (r * cos(θ) + 200)
       img.circle(x => x, y => y, r => i/(5*seeds))
   } * seeds

   return img

}

var img = draw_sunflower() img.write(file => "sunflower.png")</lang> Output image: Sunflower fractal

zkl

Translation of: Go

Uses Image Magick and the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl <lang zkl>fcn sunflower(seeds=3000){

  img,color := PPM(400,400), 0x00ff00;		// green
  c:=((5.0).sqrt() + 1)/2;
  foreach n in ([0.0 .. seeds]){  // floats
     r:=n.pow(c)/seeds;
     x,y := r.toRectangular(r.pi*c*n*2);
     r=(n/seeds*5).toInt();
     img.circle(200 + x, 200 + y, r,color);
  }
  img.writeJPGFile("sunflower.zkl.jpg");

}();</lang>

Output:

Image at sunflower fractal