crunchlife: Tag Fractals

Ruby Fractal Library 1.2.2

Ryan Baxter — Mon, 08 Mar 2010 20:34:00 -0800

The Ruby Fractal Library now uses ChunkyPNG. Thanks to Willem van Bergen for creating a 100% pure Ruby PNG solution! ChunkyPNG provides full read/write capabilities of PNG files without the dependency hassle of bigger image libraries. Install fractals and enjoy the chunky goodness.

sudo gem install fractals

Oh, and check out this post at Implements Developer for another great way to create the Mandelbrot Set in Ruby.

Ruby Fractal Library 1.2.0

Ryan Baxter — Wed, 26 Aug 2009 19:36:00 -0700

I’ve finally released version 1.2.0 of the Ruby Fractal Library. It’s still just as small and easy to use, but with a few new twists. I’ve removed most of the duplicate code, added Procs where appropriate, and made the syntax more consistent. The result is much more readable and should be easier to maintain.

The source code has been split into multiple files. One for each module.
Each of the fractals has been distilled to a single block passed to the Fractal base class’ constructor. This makes it easy to construct new orbits fractals by either inheriting from Fractal or instantiating it directly.
Classes have been added for the Burning Ship and Newton fractals.
A ‘Winter’ theme has been added.
Users can now choose which dependancy nightmare they’d prefer. PNG, RMagick and JRuby each have their own renderer. PNGRenderer is the default, but is easy to override with the renderer= method.
bailout and max_iterations are no longer constructor parameters. This is the biggest breaking change.
Unit tests have been added for each fractal.
Several rake tasks have been added to make installation and gem creation easier.
RDoc documentation is now available.

A project for this library has been created at RubyForge, but the source code can still be found at the same old place. I’m considering a move to github, but I’ll make an announcement if that happens. If you decide to download the Ruby Fractal Library, be sure to check out examples.rb in the project’s source. You should also take a look at the README file and documentation before getting started. Make some fractals and enjoy! Bugs can be filed at the RubyForge tracker.

A Couple New Fractals

Ryan Baxter — Mon, 12 Jan 2009 12:46:00 -0800

I’ve created types for both the Burning Ship and Newton fractals and added them to trunk of the Ruby Fractal Library repository. The Newton fractal was a little tricky since its formula requires the derivative of a polynomial p(z). A private “derivative” method yields the results of the expression, (f(x + dx) - f(x)) / dx when dx is provided as a parameter and p(z) is passed to the block.

private
def derivative(dx)
  lambda { |x| 
    (yield(x + dx) - yield(x)) / dx 
  }
end

Before making an official release, I’m going to do a few creative things with blocks and add one or two new coloring algorithms.

After the release, I’d like to begin experimenting with iterated functions and random fractals in hopes of making the library more well rounded. I’m also thinking about abstracting the rendering logic in an attempt to make RMagick less of a dependency. We’ll see how that goes.

The following code was used to render the fractals seen here:

burningShip = BurningShip.new(Complex(-1.75, -0.04))
burningShip.magnification = 32
burningShip.save_as('burning_ship.png')

newton = Newton.new
newton.a = -0.5
newton.pz = lambda { |z| z**3 - 1 }
newton.theme = Themes::Winter
newton.save_as('newton.png')

Once that is all said and done I’ll be taking a break from fractals to work on another pet project. I’ll post more on that when I have something to show. Cheers.

Ruby Fractal Library and RMagick?

Ryan Baxter — Tue, 11 Nov 2008 12:06:00 -0800

Sure, why not! Thanks to Brian Jones, the Ruby Fractal Library now renders fractals with RMagick. Images can be saved in formats including, PNG, GIF, JPEG, and many others. I was able to create an animated GIF displaying the magnification of the Feigenbaum point in less than 15 lines of code.

feigenbaum = Mandelbrot.new(Complex(-0.1528, 1.0397), 2, 100)
feigenbaum.width = 150
feigenbaum.height = 150
feigenbaum.m = 25
feigenbaum.algorithm = Algorithms::NormalizedIterationCount
feigenbaum.theme = Themes::Water

image_list = Magick::ImageList.new
image_list.delay = 100
image_list.iterations = 1

(0...50).each { |i|
  feigenbaum.m += (i**2)
  image_list << Magick::Image.from_blob(feigenbaum.draw('gif'))[0]
}

image_list.write('feigenbaum.gif')

The recent changes have caused a couple of breaking changes. Now that RMagick is used, ImageMagick must be installed as a dependency. I was against this at first, but RMagick’s flexibility ultimately won me over (I couldn’t resist the lure of animated fractals). The Fractal.draw method now returns an image as a BLOB, but a save_as method has been provided to handle the writing of images to disk. The curious can find that latest source code in the repo’s trunk. Stay tuned for more updates.

svn checkout -r 10 http://svn.ryanbaxter.net/fractals/trunk fractals

As always, I’ll accept any comments, suggestions, or source code. Thanks again to Brian for the RMagick submission.

Ruby Fractal Library 1.1.0

Ryan Baxter — Fri, 24 Oct 2008 11:49:00 -0700

Between spending time with the baby and working on a new project (more to come), I’ve found time to add a few features to the Ruby Fractal Library. An Algorithms module now contains lambda expressions implementing both the Escape Time and Normalized Iteration Count algorithms. Users can also create their own lambda expressions and assign them to the Fractal class’s algorithm property.

In the example below, I’ve show the difference between images rendered using the Escape Time and Normalized Iteration Count algorithms. As you can see, the Normalized Iteration Count algorithm generates images without the color banding associated with the Escape Time algorithm.

Escape Time	Normalized Iteration Count

A Themes module now serves as a home for all of the library’s predefined color palettes. There are only two, but they’re easy to make. Since themes are also expressed as lambdas they too can be created by users and applied to the Fractal class. Below is my attempt at creating a snowflake using the Julia set and a user-defined theme.

snowflakes = Julia.new(Complex(-0.3007, 0.6601), 5, 100)
snowflakes.width = 350
snowflakes.height = 350
snowflakes.m = 2
snowflakes.set_color = PNG::Color::White
snowflakes.algorithm = Algorithms::NormalizedIterationCount
snowflakes.theme = lambda { |index|
  r, g, b = 0, 0, 0      
  if index >= 510
    r = 0
    g = 255 % index
    b = 255
  elsif index >= 255
    r = 0
    g = index % 255
    b = 255
  else    
    b = index % 255
  end      
  return r, g, b
}
snowflakes.draw('snowflakes.png')

Snowflakes was inspired by a colleague who wondered why I kept creating paisley. The Fire theme will do that. :)

When I get more time I’d like to implement some of the Escape Angle and Curvature Estimation algorithms as outlined by Garcia, Fernandez, Barrallo, and Martin, but for now I’d gladly accept any user-contributed algorithms or themes.

A fractal can now be instantiated with a single point rather than a range. This is the biggest breaking change over version 1.0.0. I believe that this makes the library easier to use and more similar to other fractal generating programs. The Fractal type also contains a where_is? method. This should help when trying to determine the complex coordinate of an x, y value pair.

In testing the library, I attempted to generate a few of the fractals found in the Mandelbrot set Wikipedia entry. The images found at Wikipedia were rendered using Ultra Fractal 3 and are beautiful. Knowing Ruby, I didn’t expect to generate images with the same quality, but I was pleasantly surprised. Here is “Satellite” followed by the Misiurewicz point. Both were rendered with the Ruby Fractal Library.

Satellite	Misiurewicz point

Satellite can be found where c = -0.743643135, 0.131825963i at around 200k magnification. I had to set max_iterations = 1500 to get this level of detail. It still took a few minutes to render using the latest YARV interpreter on an Intel Core 2 Duo 2.6Ghz. Overall I’ve noticed that YARV finishes rendering the Mandelbrot set in approximately half the time of the old Matz interpreter. Not a bad gain. It’ll never be as quick as C, but I still look forward to Ruby 2.0!

The Ruby Fractal Library can be found under the “Projects” section of this website. Feel free to send me any feedback. I’d love to see some new color themes or algorithms.

Ruby Fractal Library

Ryan Baxter — Thu, 03 Jul 2008 14:26:00 -0700

*Update: Version 1.1.0 of the Ruby Fractal Library has been released.

Last October, I wrote a small fractal rendering program in Ruby using the Shoes windowing toolkit written by why the lucky stiff. It’s sole purpose was to test Shoes. The code was painfully slow at rendering the Mandelbrot set, but it did, however, begin a small obsession of mine with fractals.

Since I couldn’t find a fractal library for Ruby, I decided to write one. Over the last two weeks I’ve written some code to generate both the Mandelbrot and Julia set fractals using the escape time algorithm. The code is still slow, but within a couple weeks I hope to replace the slow portions with inline C.

There may still be some bugs and I haven’t added any error handling, but here it is. An “almost” pure Ruby fractal library. Once this is cleaned up I’ll repost the code. I suppose a gem could be possible as well. Happy 4th!

fractals.rb

# RB

require 'rubygems'
require 'complex'
require 'png'

module Fractals
  module Fractal
    attr_accessor :begin_range, :end_range

    def initialize(begin_range, end_range)
      @begin_range, @end_range = begin_range, end_range
    end

    def draw(height=250, width=250, m=1.0, save_as='fractal.png')
        canvas = PNG::Canvas.new(height, width)

        # Find the complex coordinate for each pixel.
        0.upto(height - 1) { |y|
          i = (y * (@end_range.image - @begin_range.image) / height +
          @begin_range.image) * m
          0.upto(width - 1) { |x|
            r = (x * (@end_range.real - @begin_range.real) / width +
            @begin_range.real) * m
            if self.in_set?(Complex(r, i)) then
              canvas[x, y] = PNG::Color::Black
            else
              canvas[x, y] = fetch_color(self.last_iteration, self.max_iterations)
            end                    
          }
        }

        png = PNG.new(canvas)
        png.save(save_as)
    end  

    private
    def fetch_color(last_iteration, max_iterations)  
      divisor = 765*last_iteration/max_iterations
      case divisor
        when 0..254 then return PNG::Color.new(divisor%255, 0, 0, 255)
        when 255..509 then return PNG::Color.new(255, divisor%255, 0, 255)
        when 510..765 then return PNG::Color.new(255, 255, divisor%255, 255)
      end       
    end
  end

  class Julia
    include Fractal
    attr_accessor :seed, :bailout, :max_iterations
    attr_reader :last_iteration

    def initialize(seed=Complex(0.36, 0.1), bailout=2, max_iterations=100,
    begin_range=Complex(-2.25, -1.5), end_range=Complex(0.75, 1.5))
      super(begin_range, end_range)
      @seed, @bailout, @max_iterations = seed, bailout, max_iterations
    end

    def in_set?(z)
      @max_iterations.times { |i|
        z = z**2 + @seed
        if z > @bailout then
          @last_iteration = i
          return false
        end      
      }
      return true
    end
  end

  class Mandelbrot
    include Fractal  
    attr_accessor :bailout, :max_iterations
    attr_reader :last_iteration

    def initialize(bailout=5, max_iterations=100, begin_range=Complex(-2.25,
    -1.5), end_range=Complex(0.75, 1.5))
      super(begin_range, end_range)
      @bailout, @max_iterations = bailout, max_iterations
    end

    def in_set?(c)
      z = 0
      @max_iterations.times { |i|
        z = z**2 + c
        if z > @bailout then
          @last_iteration = i
          return false
        end            
      }
      return true
    end
  end
end

Using this library is as simple as the following:

require 'fractals'

mandelbrot = Fractals::Mandelbrot.new
mandelbrot.draw

Any suggestions/bug fixes can be posted here. Thanks.