cf3 0.0.1

data/README.md

@@ -0,0 +1,35 @@
+# cf3ruby
+
+**context-free DSL for ruby-1.9 and CF3 syntax** 
+
+Very much derived from [context-free.rb][] by Jeremy Ashkenas this version is updated to be more in line with CF3 and ruby 1.9 syntax. Tested as working with last rubygems release of ruby-processing (v 1.0.11) as well as the current [version][] (v 2.1.0).
+[context-free.rb]:https://github.com/jashkenas/context_free/
+[version]:https://github.com/monkstone/ruby-processing/releases/
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cf3ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cf3
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+![Y](http://3.bp.blogspot.com/-KNBKD7lArMA/UNBayboXQFI/AAAAAAAAD7A/YAgZCewTOxQ/s400/y.png)
+

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+
+task :install => :build do
+  sh "jruby -S gem install #{Dir.glob('*.gem').join(' ')} --no-ri --no-rdoc"
+end
+
+task :build do
+  sh "gem build cf3ruby.gemspec"
+end
+
+task :test do
+  sh "jruby -S rp5 run test/test_cf3.rb"
+end
+
+task :default => [:install]

data/bin/cf3samples

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#####
+# Extract samples into users home directory
+#####
+
+
+home = ENV["HOME"]
+local = home + '/cf3samples'
+file = __FILE__
+require "pathname" 
+require "fileutils"
+file = Pathname.new(file).realpath
+
+sample_dir = File.expand_path(File.dirname(file) + "/../samples")
+FileUtils.mkdir local unless Dir.exists? local
+FileUtils.cp_r sample_dir, local

data/cf3ruby.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cf3/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cf3"
+  spec.version       = Cf3::VERSION
+  spec.authors       = ["Jeremy Ashkenas", "Martin Prout"]
+  spec.email         = ["martin_p@lineone.net"]
+  spec.description   = <<-EOF
+    A library for ruby-processing, that allows the writing of context free 
+    sketches (like context free art) in a ruby DSL. It is a bit of a toy
+    compared to the c++ version.  However you can get quite a bit of 
+    satisfaction creating an interesting graphic, and you can't always
+    predict what you are going to get.
+  EOF
+  spec.summary       = %q{A ruby-DSL library for CF3 sketches}
+  spec.homepage      = "http://learning-ruby-processing.blogspot.co.uk/"
+  spec.default_executable   = "cf3samples" 
+  spec.license       = "GPL3"
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.executables   = ["cf3samples"] 
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency 'ruby-processing', '>= 1.0.11'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/cf3.rb

@@ -0,0 +1,240 @@
+# A Context-Free library for Ruby-Processing, inspired by
+# based on context_free.rb by Jeremy Ashkenas. Which in turn
+# was inspired by contextfreeart.org
+
+module Processing
+
+  class ContextFree
+
+    include Processing::Proxy
+
+    attr_accessor :rule, :app, :width, :height
+
+    AVAILABLE_OPTIONS = [:x, :y, :rotation, :size, :flip, :color, :hue, :saturation, :brightness, :alpha]
+    HSB_ORDER         = {hue: 0, saturation: 1, brightness: 2, alpha: 3}
+    TRIANGLE_TOP      = -1 / Math.sqrt(3)
+    TRIANGLE_BOTTOM   = Math.sqrt(3) / 6
+
+    # Define a context-free system. Use this method to create a ContextFree
+    # object. Call render() on it to make it draw.
+    def self.define(&block)
+      cf = ContextFree.new
+      cf.instance_eval &block
+      cf
+    end
+
+
+    # Initialize a bare ContextFree object with empty recursion stacks.
+    def initialize
+      @app          = $app
+      @graphics     = $app.g
+      @width        = $app.width
+      @height       = $app.height
+      @finished     = false
+      @rules        = {}
+      @rewind_stack = []
+      @matrix_stack = []
+    end
+
+
+    # Create an accessor for the current value of every option. We use a values
+    # object so that all the state can be saved and restored as a unit.
+    AVAILABLE_OPTIONS.each do |option_name|
+      define_method option_name do
+        @values[option_name]
+      end
+    end
+
+
+    # Here's the first serious method: A Rule has an
+    # identifying name, a probability, and is associated with
+    # a block of code. These code blocks are saved, and indexed
+    # by name in a hash, to be run later, when needed.
+    # The method then dynamically defines a method of the same
+    # name here, in order to determine which rule to run.
+    def shape(rule_name, prob=1, &proc)
+      @rules[rule_name] ||= {procs: [], total: 0}
+      total = @rules[rule_name][:total]
+      @rules[rule_name][:procs] << [(total...(prob+total)), proc]
+      @rules[rule_name][:total] += prob
+      unless ContextFree.method_defined? rule_name
+        self.class.class_eval do
+          eval <<-METH
+            def #{rule_name}(options)
+              merge_options(@values, options)
+              pick = determine_rule(#{rule_name.inspect})
+              @finished = true if @values[:size] < @values[:stop_size]
+              unless @finished
+                get_ready_to_draw
+                pick[1].call(options)
+              end
+            end
+          METH
+        end
+      end
+    end
+
+
+    # Rule choice is random, based on the assigned probabilities.
+    def determine_rule(rule_name)
+      rule = @rules[rule_name]
+      chance = rand * rule[:total]
+      pick = @rules[rule_name][:procs].select {|the_proc| the_proc[0].include?(chance) }
+      return pick.flatten
+    end
+
+
+    # At each step of the way, any of the options may change, slightly.
+    # Many of them have different strategies for being merged.
+    def merge_options(old_ops, new_ops)
+      return unless new_ops
+      # Do size first
+      old_ops[:size] *= new_ops[:size] if new_ops[:size]
+      new_ops.each do |key, value|
+        case key
+        when :size
+        when :x, :y
+          old_ops[key] = value * old_ops[:size]
+        when :rotation
+          old_ops[key] = value * (Math::PI / 180.0)
+        when :hue, :saturation, :brightness, :alpha
+          adjusted = old_ops[:color].dup
+          adjusted[HSB_ORDER[key]] *= value
+          old_ops[:color] = adjusted
+        when :flip
+          old_ops[key] = !old_ops[key]
+        when :width, :height
+          old_ops[key] *= value
+        when :color
+          old_ops[key] = value
+        else # Used a key that we don't know about or trying to set
+          merge_unknown_key(key, value, old_ops)
+        end
+      end
+    end
+
+
+    # Using an unknown key let's you set arbitrary values,
+    # to keep track of for your own ends.
+    def merge_unknown_key(key, value, old_ops)
+      key_s = key.to_s
+      if key_s.match(/^set/)
+        key_sym = key_s.sub('set_', '').to_sym
+        if key_s.match(/(brightness|hue|saturation)/)
+          adjusted = old_ops[:color].dup
+          adjusted[HSB_ORDER[key_sym]] = value
+          old_ops[:color] = adjusted
+        else
+          old_ops[key_sym] = value
+        end
+      end
+    end
+
+
+    # Doing a 'split' saves the context, and proceeds from there,
+    # allowing you to rewind to where you split from at any moment.
+    def split(options=nil, &block)
+      save_context
+      merge_options(@values, options) if options
+      yield
+      restore_context
+    end
+
+
+    # Saving the context means the values plus the coordinate matrix.
+    def save_context
+      @rewind_stack.push @values.dup
+      @matrix_stack << @graphics.get_matrix
+    end
+
+
+    # Restore the values and the coordinate matrix as the recursion unwinds.
+    def restore_context
+      @values = @rewind_stack.pop
+      @graphics.set_matrix @matrix_stack.pop
+    end
+
+
+    # Rewinding goes back one step.
+    def rewind
+      @finished = false
+      restore_context
+      save_context
+    end
+
+
+    # Render the is method that kicks it all off, initializing the options
+    # and calling the first rule.
+    def render(rule_name, starting_values={})
+      @values = {x: 0, y: 0,
+                 rotation: 0, flip: false,
+                 size: 20, width: 20, height: 20,
+                 start_x: width/2, start_y: height/2,
+                 color: [0.5, 0.5, 0.5, 1],
+                 stop_size: 1.5}
+      @values.merge!(starting_values)
+      @finished = false
+      @app.reset_matrix
+      @app.rect_mode CENTER
+      @app.ellipse_mode CENTER
+      @app.no_stroke
+      @app.color_mode HSB, 1.0
+      @app.translate @values[:start_x], @values[:start_y]
+      self.send(rule_name, {})
+    end
+
+
+    # Before actually drawing the next step, we need to move to the appropriate
+    # location.
+    def get_ready_to_draw
+      @app.translate(@values[:x], @values[:y])
+      sign = (@values[:flip] ? -1 : 1)
+      @app.rotate(sign * @values[:rotation])
+    end
+
+
+    # Compute the rendering parameters for drawing a shape.
+    def get_shape_values(some_options)
+      old_ops = @values.dup
+      merge_options(old_ops, some_options) if some_options
+      @app.fill *old_ops[:color]
+      return old_ops[:size], old_ops
+    end
+
+
+    # Square, circle, and ellipse are the primitive drawing
+    # methods, but hopefully triangles will be added soon.
+    def square(some_options=nil)
+      size, options = *get_shape_values(some_options)
+      @app.rect(0, 0, size, size)
+    end
+
+
+    def circle(some_options=nil)
+      size, options = *get_shape_values(some_options)
+      @app.ellipse(0, 0, size, size)
+    end
+
+    def triangle(some_options=nil)
+      rot = some_options[:rotation]
+      @app.rotate(rot) if rot
+      size, options = *get_shape_values(some_options)
+      @app.triangle(0, TRIANGLE_TOP * size, 0.5 * size, TRIANGLE_BOTTOM * size, -0.5 * size, TRIANGLE_BOTTOM * size)
+      @app.rotate(-rot) if rot
+    end
+
+
+    def ellipse(some_options={})
+      rot = some_options[:rotation]
+      @app.rotate(rot) if rot
+      size, options = *get_shape_values(some_options)
+      width = options[:width] || options[:size]
+      height = options[:height] || options[:size]
+      @app.oval(options[:x] || 0, options[:y] || 0, width, height)
+      @app.rotate(-rot) if rot
+    end
+    alias_method :oval, :ellipse
+
+  end
+
+end

data/lib/cf3/version.rb

@@ -0,0 +1,3 @@
+module Cf3
+  VERSION = "0.0.1"
+end

data/samples/accident.rb

@@ -0,0 +1,98 @@
+#########################
+# rubystar.rb 
+#########################
+require 'cf3' 
+
+PHI = (1 + Math.sqrt(5)) / 2
+
+def setup_the_sunstar
+  @hexa = ContextFree.define do
+  ############ Begin defining custom terminals, as a sharp and flat triangles 
+    class << self
+    include Math
+      define_method(:sharp) do |some_options| 
+        size, options = *self.get_shape_values(some_options)
+        rot = options[:rotation]        
+        #f = (options[:flip])? -1 : 1
+        @app.rotate(rot) if rot 
+        #@app.triangle(0, 0, size * cos(0), size * sin(0), size * cos(PI * f/5), size * sin(PI*f/5))
+        @app.triangle(0, 0, size * cos(0), size * sin(0), size * cos(PI/5), size * sin(PI/5))
+        @app.rotate(-rot) if rot
+      end
+      define_method(:flat) do |some_options| 
+        size, options = *self.get_shape_values(some_options)
+        rot = options[:rotation]
+        f = (options[:flip])? -1 : 1                           # NB custom flip adjustment
+        @app.triangle(0, 0, size * cos(0), size * sin(0), size/PHI * cos(PI * f/5 ), size/PHI * sin(PI * f/5))
+        @app.rotate(-rot) if rot
+      end
+    end
+    ########### End definition of custom terminals 'sharp and flat'
+    
+    shape :tiling do
+      outer brightness: 1.0
+    end
+  
+    
+    shape :outer do
+      split do
+      10.times do       
+        sunstar y: sqrt((PHI)** - 0.125), rotation: 36
+      end
+      rewind
+      end
+      outer size: 1/PHI
+    end  
+    
+    
+    shape :sunstar do
+      split do
+      sun brightness: 0.8 
+      rewind
+      star brightness: 0.8, alpha: 0.8
+      rewind
+      end
+    end
+    
+    shape :dart do
+      flat size: 1, color: [0.18, 0.6, 0.6] 
+      flat size: 1, color: [0.18, 1.0, 1.0], flip: true
+    end
+    
+    shape :kite do 
+      sharp size: 1, color: [0, 0.6, 0.6] 
+      sharp size: 1, color: [0, 1.0, 1.0], rotation: 180, flip: true
+    end
+    
+    shape :star do      
+      split do
+        5.times do |i|
+          dart rotation: 72 * i 
+          rewind
+        end
+      end
+    end
+    
+    shape :sun do
+      split do
+        5.times do |i|
+          kite rotation: 72 * i
+          rewind
+        end
+      end
+    end
+  end
+end
+
+def setup
+  size 800, 820
+  background 150, 20, 0 
+  smooth
+  setup_the_sunstar
+  draw_it
+end
+
+def draw_it
+  @hexa.render :tiling, start_x: width * 0.75, start_y: height/2.64, 
+               size: height/6 
+end

data/samples/alhambra.rb

@@ -0,0 +1,79 @@
+require 'cf3'
+
+def setup_the_tiles
+  @tiles= ContextFree.define do
+    ############ Begin defining custom terminal, an wavy_triangle triangle        
+    class << self    
+      define_method(:wavy_triangle) do |some_options| # wavy_triangle triangle
+        size, options = *self.get_shape_values(some_options)
+        rot = options[:rotation]
+        disp = 0.32          # could introduce a rule option?
+        x0 = options[:x]
+        y0 = options[:y]
+        pts = Array.new(12)
+        pts[0] = PVector.new(x0, y0 - size/Math.sqrt(3))                  # A
+        pts[1] = PVector.new(x0 - 0.5 * size, y0 + (Math.sqrt(3)*size)/6) # B
+        pts[2] = PVector.new(x0 + 0.5 * size, y0 + (Math.sqrt(3)*size)/6) # C
+        pts[3] = get_mid_point(pts[0], pts[1])                            # Ab
+        pts[4] = get_mid_point(pts[1], pts[2])                            # Bc
+        pts[5] = get_mid_point(pts[0], pts[2])                            # Ca
+        pts[6] = get_mid_point(pts[0], pts[3])                            # Aba
+        adjust_bezier(pts[6], PI/3, disp*size)                            # Aba
+        pts[7] = get_mid_point(pts[3], pts[1])                            # Abb
+        adjust_bezier(pts[7], PI/3, -disp*size)                           # Abb
+        pts[8] = get_mid_point(pts[1], pts[4])
+        adjust_bezier(pts[8], PI/2, -disp*size)
+        pts[9] = get_mid_point(pts[4], pts[2])
+        adjust_bezier(pts[9], PI/2, disp*size)
+        pts[10] = get_mid_point(pts[2], pts[5])
+        adjust_bezier(pts[10], -PI/3, -disp*size)
+        pts[11] = get_mid_point(pts[5], pts[0])
+        adjust_bezier(pts[11], -PI/3, disp*size)
+        rotate(rot) if rot
+        begin_shape
+          vertex(pts[0].x, pts[0].y)
+          bezier_vertex(pts[0].x, pts[0].y, pts[6].x, pts[6].y, pts[3].x, pts[3].y)
+          bezier_vertex(pts[3].x, pts[3].y, pts[7].x, pts[7].y, pts[1].x, pts[1].y)
+          bezier_vertex(pts[1].x, pts[1].y, pts[8].x, pts[8].y, pts[4].x, pts[4].y)
+          bezier_vertex(pts[4].x, pts[4].y, pts[9].x, pts[9].y, pts[2].x, pts[2].y)
+          bezier_vertex(pts[2].x, pts[2].y, pts[10].x, pts[10].y, pts[5].x, pts[5].y)
+          bezier_vertex(pts[5].x, pts[5].y, pts[11].x, pts[11].y, pts[0].x, pts[0].y)
+        end_shape(CLOSE)        
+        rotate(-rot) if rot
+      end
+    
+      private
+      def adjust_bezier(base, theta, disp)
+        base.add(PVector.new(Math.cos(theta)*disp, Math.sin(theta)*disp))
+      end
+    
+      def get_mid_point(a, b)
+        mid = PVector.add(a, b)
+        mid.div(2)
+        return mid
+      end
+    end
+  
+    ########### End definition of custom terminal 'wavy_triangle' shape
+    shape :tiles do
+      10.times do |i|
+        10.times do |j|
+          wavy_triangle size: 1, x: (i + 0.5 * j%2), y: j * 0.9
+        end
+      end
+    end
+  end
+end
+
+def setup
+  size 400, 400
+  background 255
+  smooth
+  setup_the_tiles
+  draw_it
+end
+
+def draw_it
+  @tiles.render :tiles, start_x: -50, start_y: 20,
+               size: height/6, color: [0, 0.8, 0.8, 1]
+end