paulnicholson-acrylic 0.1.0

data/lib/cairo_tools.rb

@@ -0,0 +1,200 @@
+require 'rubygems'
+require 'active_support'
+require 'cairo'
+require 'gdk_pixbuf2'
+require 'color'
+require 'text_box'
+require 'image_surface_extensions'
+require 'inline'
+
+module CairoTools
+  include Color
+  attr_reader :surface, :cr, :canvas_height, :canvas_width, :top_margin, :right_margin, :bottom_margin, :left_margin
+  attr_accessor :preview
+
+  def generate_image(path, options)
+    # dummy context is useful sometimes
+    @surface = Cairo::ImageSurface.new(1, 1)
+    @cr = Cairo::Context.new(surface)
+    draw(*options)
+    cr.target.write_to_png(path)
+  end
+
+  def dimensions(width, height)
+    @canvas_width, @canvas_height = width, height
+    @surface = Cairo::ImageSurface.new(width, height)
+    @cr = Cairo::Context.new(surface)
+  end
+  
+  def margin(*rect)
+    rect = rect + rect if rect.length == 1
+    rect = rect + rect if rect.length == 2
+    @top_margin, @right_margin, @bottom_margin, @left_margin = rect
+    cr.matrix = Cairo::Matrix.identity.translate(left_margin, top_margin)
+  end
+  
+  def width
+    canvas_width - right_margin - left_margin
+  end
+  
+  def height
+    canvas_height - top_margin - bottom_margin
+  end
+  
+  def transform(matrix, &block)
+    old_matrix = cr.matrix
+    cr.matrix = matrix
+    yield
+    cr.matrix = old_matrix
+  end
+
+  # http://www.cairographics.org/cookbook/roundedrectangles/
+  def rounded_rectangle(x, y, w, h, radius_x=5, radius_y=radius_x)
+    arc_to_bezier = 0.55228475
+    radius_x = w / 2 if radius_x > w - radius_x
+    radius_y = h / 2 if radius_y > h - radius_y
+    c1 = arc_to_bezier * radius_x
+    c2 = arc_to_bezier * radius_y
+
+    cr.new_path
+    cr.move_to(x + radius_x, y)
+    cr.rel_line_to(w - 2 * radius_x, 0.0)
+    cr.rel_curve_to(c1, 0.0, radius_x, c2, radius_x, radius_y)
+    cr.rel_line_to(0, h - 2 * radius_y)
+    cr.rel_curve_to(0.0, c2, c1 - radius_x, radius_y, -radius_x, radius_y)
+    cr.rel_line_to(-w + 2 * radius_x, 0)
+    cr.rel_curve_to(-c1, 0, -radius_x, -c2, -radius_x, -radius_y)
+    cr.rel_line_to(0, -h + 2 * radius_y)
+    cr.rel_curve_to(0.0, -c2, radius_x - c1, -radius_y, radius_x, -radius_y)
+    cr.close_path
+  end
+
+  def circular_text(x, y, radius, font_size, text)
+    radians = proc {|text| cr.set_font_size(font_size); cr.text_extents(text).x_advance/radius}
+    blank = (2*Math::PI - radians[text])/2
+    start = blank + Math::PI/2
+    partial = ''
+    text.split(//).each do |letter|
+      theta = start + radians[partial]
+      cr.move_to(x+radius*Math.cos(theta), y+radius*Math.sin(theta))
+      cr.set_font_matrix Cairo::Matrix.identity.rotate(theta + Math::PI/2).scale(font_size, font_size)
+      cr.show_text letter
+      theta += radians[letter]
+      partial << letter
+    end
+  end
+
+  def create_text_box(x, y, width=nil, height=nil, valign=:top)
+    TextBox.new(self, x, y, width, height, valign)
+  end
+
+  def draw_text_box(x, y, width=nil, height=nil, valign=:top)
+    tb = create_text_box(x, y, width, height, valign)
+    yield tb
+    tb.draw
+  end
+
+  def set_color(color)
+    cr.set_source_rgba(*color.to_rgb.to_a)
+  end
+
+  def linear_gradient(x0, y0, x1, y1, *colors)
+    gradient(Cairo::LinearPattern.new(x0, y0, x1, y1), *colors)
+  end
+
+  def radial_gradient(cx0, cy0, r0, cx1, cy1, r1, *colors)
+    gradient(Cairo::RadialPattern.new(cx0, cy0, r0, cx1, cy1, r1), *colors)
+  end
+
+  def gradient(gradient, *colors)
+    colors.each_with_index do |color, i|
+      array = color.respond_to?(:to_rgb) ? color.to_rgb.to_a : color.to_a
+      gradient.add_color_stop(i.to_f/(colors.length - 1), *array)
+    end
+    cr.set_source(gradient)
+  end
+
+  def shadow(radius=3, alpha=1)
+    shadow_surface = Cairo::ImageSurface.new(@canvas_width, @canvas_height)
+    shadow_cr = Cairo::Context.new(shadow_surface)
+    shadow_cr.set_source_rgba(0, 0, 0, alpha)
+    shadow_cr.mask(Cairo::SurfacePattern.new(surface))
+    shadow_surface.blur(radius)
+    shadow_cr.set_source(Cairo::SurfacePattern.new(surface))
+    shadow_cr.paint
+    @surface = shadow_surface
+    @cr = shadow_cr
+  end
+  
+  def get_pixel(x, y)
+    @surface.get_pixel(x, y)
+  end
+  
+  def load_image(path, x=0, y=0)
+    image = Gdk::Pixbuf.new(File.join(File.dirname($0), path))
+    cr.set_source_pixbuf(image)
+    cr.source.matrix = Cairo::Matrix.identity.translate(x, y)
+  end
+  
+  def clip!
+    i = self.class.new
+    w, h = @canvas_width, @canvas_height
+    pattern = Cairo::SurfacePattern.new(@surface)
+    clip = cr.copy_path
+    i.instance_eval do
+      dimensions w, h
+      cr.append_path clip
+      cr.clip
+      cr.set_source(pattern)
+      cr.paint
+    end
+    dimensions w, h
+    cr.set_source(Cairo::SurfacePattern.new(i.surface))
+    cr.paint
+  end
+  
+  def transparent!(alpha)
+    i = self.class.new
+    w, h = @canvas_width, @canvas_height
+    pattern = Cairo::SurfacePattern.new(@surface)
+    i.instance_eval do
+      dimensions w, h
+      cr.set_source(pattern)
+      cr.paint_with_alpha(alpha)
+    end
+    @surface = i.surface
+    @cr = i.cr
+  end
+  
+  def draw_image(image, x=0, y=0, a=1)
+    i = self.class.new
+    i.instance_eval do
+      draw(image)
+    end
+    cr.set_source(Cairo::SurfacePattern.new(i.surface))
+    cr.source.matrix = Cairo::Matrix.identity.translate(-x, -y)
+    cr.paint_with_alpha(a)
+  end
+  
+  def clouds
+    Cairo::ImageSurface.new(129, 129)
+  end
+end
+
+class Cairo::Context
+  inline(:C) do |builder|
+    builder.include '<stdlib.h>'
+    builder.include '<cairo.h>'
+    builder.include '<rb_cairo.h>'
+    builder.include '<intern.h>'
+    builder.add_compile_flags '`/opt/local/bin/pkg-config --cflags cairo`'
+    builder.add_compile_flags '-I/opt/local/lib/ruby/site_ruby/1.8/i686-darwin9/'
+    builder.add_compile_flags '-I/opt/local/lib/ruby/gems/1.8/gems/cairo-1.6.2/src'
+    builder.c %{
+      void paint_with_alpha(double alpha) {
+        cairo_t *cr = RVAL2CRCONTEXT(self);
+        cairo_paint_with_alpha(cr, alpha);
+      }
+    }
+  end
+end

data/lib/color.rb

@@ -0,0 +1,149 @@
+require 'rubygems'
+require 'active_support'
+require 'core_ext'
+
+module Color
+  def rgb(*args)
+    RGB.new(*args)
+  end
+
+  def hsl(*args)
+    HSL.new(*args)
+  end
+
+  class Base
+    def self.inherited(subclass)
+      components = subclass.name.sub('Color::', '').downcase.split(//).map(&:to_sym)
+      components << :a
+      components.each_with_index do |component, i|
+        subclass.class_eval <<-"end;"
+          def #{component}(value=nil)
+            if value
+              result = self.class.new(@components)
+              result.#{component} = value
+              result
+            else
+              @components[#{i}]
+            end
+          end
+          def #{component}=(x)
+            @components[#{i}] = constrain(x)
+          end
+        end;
+      end
+    end
+
+    def initialize(*components)
+      if components[0].is_a?(String)
+        @components = []
+        self.css = components[0]
+      else
+        @components = components.flatten.map(&method(:constrain))
+      end
+      @components << 1.0 if @components.size == 3
+    end
+    
+    def primary_components
+      @components[0..-2]
+    end
+    
+    def to_a
+      @components
+    end
+
+    def -(other)
+      self + other.to_a.map(&:-@)
+    end
+
+    def +(other)
+      other_array = other.to_a
+      array = component_indicies.map {|i| @components[i] + (other_array[i] || 0)}
+      self.class.new(*array)
+    end
+
+    def ==(other)
+      other.class == self.class && component_indicies.all? {|i| epsilon(@components[i] - other.to_a[i])}
+    end
+    
+    def to_s
+      "<#{self.class.name}: #{@components.join(", ")}>"
+    end
+
+    protected
+    def component_indicies
+      (0..@components.size - 1).to_a
+    end
+
+    def epsilon(x)
+      x.abs <= 0.01
+    end
+
+    def constrain(x)
+      x > 1.0 ? 1.0 : x < 0.0 ? 0.0 : x
+    end
+  end
+
+  class RGB < Base
+    def css=(string)
+      string.gsub!('#', '')
+      self.r, self.g, self.b = string.split(//).in_groups_of(string.length/3).map {|a| a.join.to_i(16).to_f / (16 ** (string.length/3) - 1).to_f}
+    end
+
+    def to_hsl
+      max = primary_components.max
+      min = primary_components.min
+      compute_hue = proc do |numerator, degrees|
+        degrees(60) * (numerator / (max - min)) + degrees(degrees)
+      end
+      l = (max + min)/2.0
+      s = (epsilon(l) || epsilon(max - min)) ? 0 :
+        l <= 0.5 ? (max - min) / (max + min) :
+          (max - min) / (2 - (max + min))
+      h = epsilon(max - min) ? 0 :
+          max == r ? compute_hue[g - b, g >= b ? 0 : 360] :
+          max == g ? compute_hue[b - r, 120] :
+                     compute_hue[r - g, 240]
+      HSL.new(h, s, l, a)
+    end
+
+    def to_css
+      "%02X" * 3 % @components.map {|c| c * 255}
+    end
+    
+    def to_rgb
+      self
+    end
+
+    protected
+    def degrees(x)
+      x.to_f/360.0
+    end
+  end
+
+  class HSL < Base
+    def to_rgb
+      return RGB.new(l, l, l, a) if epsilon(s)
+      q = l < 0.5 ? l * (1.0 + s) : (l + s) - l * s
+      p = 2 * l - q
+      tc = [h + 1.0/3.0, h, h - 1.0/3.0]
+      tc.map! do |x|
+        x < 0 ? x + 1.0 :
+          x > 1.0 ? x - 1.0 : x
+      end
+      rgb = tc.map do |tc|
+        tc < 1.0/6.0 ? p + ((q - p) * 6.0 * tc) :
+        tc < 3.0/6.0 ? q :
+        tc < 4.0/6.0 ? p + ((q - p) * 6.0 * (2.0/3.0 - tc)) : p
+      end
+      RGB.new(rgb + [a])
+    end
+
+    def to_css
+      to_rgb.to_css
+    end
+    
+    def css=(string)
+      self.h, self.s, self.l = RGB.new(string).to_hsl.to_a
+    end
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,16 @@
+class Symbol
+  def self.pattern(name, pattern, &formation)
+    define_method(name) {to_s.match(pattern) ? self : formation.call(self).to_sym}
+    define_method(name.question) {to_s.match(pattern)}
+  end
+  pattern(:question, /\?$/) {|s| "#{s}?"}
+  pattern(:bang, /!$/) {|s| "#{s}!"}
+  pattern(:writer, /=$/) {|s| "#{s}="}
+  pattern(:iv, /^@[^@]/) {|s| "@#{s}"}
+end
+
+class Numeric
+  def deg
+    self / 180.0 * Math::PI
+  end
+end

data/lib/curve.rb

@@ -0,0 +1,120 @@
+class Curve < Array
+  attr_accessor :cr
+
+  def initialize(cr)
+    @cr = cr
+  end
+
+  def draw
+    draw_control_points(self)
+  end
+
+  def draw_control_points(control_points)
+    cr.move_to(*control_points.first.point)
+    cx1, cy1 = control_points.first.leading_point
+    control_points[1..-1].each do |point|
+      cx2, cy2 = point.trailing_point
+      cr.curve_to(cx1, cy1, cx2, cy2, point.x, point.y)
+      cx1, cy1 = point.leading_point
+    end
+  end
+
+  def offset_line(distance, flip)
+    offset_line = self.map do |p|
+      p.move_away_from_line(distance)
+    end
+    offset_line.each_with_index do |p, i|
+      p.d1 *= (p.distance(offset_line[i-1])/self[i].distance(self[i-1])) * 1.1 unless i == 0
+      p.d2 *= (p.distance(offset_line[i+1])/self[i].distance(self[i+1])) * 1.1 unless i + 1 == length
+    end
+    flip ? offset_line.map(&:flip).reverse : offset_line
+  end
+
+  def draw_outline
+    there = offset_line(-2, false)
+    there.first.d1 = 5
+    back = offset_line(2, true)
+    back.last.d2 = 2
+    draw_control_points(there + back + [there.first])
+    cr.stroke
+    # cr.fill
+  end
+
+  def debug
+    each do |point|
+      cr.circle(point.x, point.y, 3)
+      cr.fill
+      cr.line_width = 1
+      # cr.move_to(*point.trailing_point.map {|n| n + 2})
+      cr.move_to(*point.trailing_point)
+      cr.line_to(*point.leading_point)
+      cr.stroke
+    end
+  end
+
+  def point(x, y, theta, d1, d2=d1)
+    p [x, y, theta, d1, d2]
+    push(ControlPoint.new(x, y, theta, d1, d2))
+  end
+
+  def spiral(center_x, center_y, theta_one, delta_theta, phi, &algorithm)
+    control_points_per_rotation = 8
+    control_points = (control_points_per_rotation * delta_theta.abs / Math::PI / 2).to_i
+    radians_between_points = delta_theta / (control_points-1)
+    (0...control_points).each do |i|
+      theta = theta_one + radians_between_points * i
+      radius = algorithm.call(theta)
+      x, y = center_x + radius * Math.cos(theta), center_y + radius * Math.sin(theta)
+      tangent = theta + phi
+      influence = radius * 0.285 * (delta_theta / delta_theta.abs)
+      if i == control_points - 1
+        point(x, y, tangent, influence, influence * 2)
+      elsif i == 0
+        point(x, y, tangent, influence * 3, influence)
+      else
+        point(x, y, tangent, influence)
+      end
+    end
+  end
+
+  def logarithmic_spiral(center_x, center_y, theta_one, delta_theta, a, b)
+    spiral(center_x, center_y, theta_one, delta_theta, Math.atan(1/b)) do |theta|
+      (a*Math::E)**(b*theta)
+    end
+  end
+end
+
+class ControlPoint
+  attr_accessor :x, :y, :theta, :d1, :d2
+  def initialize(x, y, theta, d1, d2=d1)
+    @x, @y, @theta, @d1, @d2 = x, y, theta, d1, d2
+  end
+
+  def point
+    [x, y]
+  end
+
+  def distance(point)
+    Math.sqrt((x - point.x) ** 2 + (y - point.y) ** 2)
+  end
+
+  def trailing_point
+    [x - d1 * Math.cos(theta), y - d1 * Math.sin(theta)]
+  end
+
+  def leading_point
+    [x + d2 * Math.cos(theta), y + d2 * Math.sin(theta)]
+  end
+
+  def flip
+    ControlPoint.new(x, y, theta + 180.deg, d2, d1)
+  end
+
+  def move_away_from_line(delta)
+    ControlPoint.new(x + delta * Math.cos(theta - 90.deg) * d1/d1.abs, y + delta * Math.sin(theta - 90.deg) * d1/d1.abs, theta, d1, d2)
+  end
+
+  def move_along_line(delta)
+    ControlPoint.new(x + delta * Math.cos(theta) * d1/d1.abs, y + delta * Math.sin(theta) * d1/d1.abs, theta, d1, d2)
+  end
+end