vector_salad 0.0.1

data/lib/vector_salad/interpolate.rb

@@ -0,0 +1,57 @@
+# Code adapted from:
+# http://jeremykun.com/2013/05/11/bezier-curves-and-picasso/
+#
+# Interpolate a cubic bezier spline into straight line segments,
+# using the De Casteljau algorithm.
+module VectorSalad
+  class Interpolate
+    #TOLERANCE = 10 # anything below 50 is roughly good-looking
+    TOLERANCE = 0.2 # anything below 50 is roughly good-looking
+
+    def initialize
+      @nodes = []
+    end
+
+    def casteljau(curve)
+      if flat_enough? curve
+        @nodes << curve[3]
+      else
+        halves = subdivide(curve)
+        casteljau(halves[0])
+        casteljau(halves[1])
+      end
+    end
+
+    # Early stopping function for the Casteljau algorithm.
+    # Is the curve flat enough for visual purposes?
+    def flat_enough?(curve)
+      ax = (3.0*curve[1][0] - 2.0*curve[0][0] - curve[3][0])**2
+      ay = (3.0*curve[1][1] - 2.0*curve[0][1] - curve[3][1])**2
+      bx = (3.0*curve[2][0] - curve[0][0] - 2.0*curve[3][0])**2
+      by = (3.0*curve[2][1] - curve[0][1] - 2.0*curve[3][1])**2
+
+      [ax, bx].max + [ay, by].max <= TOLERANCE
+    end
+
+    def midpoint(p, q)
+      [(p[0] + q[0]) / 2.0, (p[1] + q[1]) / 2.0]
+    end
+
+    def midpoints(points)
+      midpoints = Array.new(points.length - 1)
+      midpoints.each_index do |i|
+        midpoints[i] = midpoint(points[i], points[i+1])
+      end
+      midpoints
+    end
+
+    def subdivide(curve)
+      first = midpoints(curve)
+      second = midpoints(first)
+      third = midpoints(second)
+
+      [[curve[0], first[0], second[0], third[0]],
+      [third[0], second[1], first[2], curve[3]]]
+    end
+  end
+end

data/lib/vector_salad/magic.rb

@@ -0,0 +1,17 @@
+require 'vector_salad/canvas'
+require 'vector_salad/dsl'
+Dir.glob(File.expand_path('../standard_shapes/*.rb', __FILE__)).each do |file|
+  require file
+end
+
+module VectorSalad
+  module Magic
+    def canvas
+      @vs_canvas ||= VectorSalad::Canvas.new
+    end
+  end
+end
+
+extend VectorSalad::DSL
+extend VectorSalad::Magic
+include VectorSalad::StandardShapes

data/lib/vector_salad/mixins/at.rb

@@ -0,0 +1,28 @@
+module VectorSalad
+  module Mixins
+    module At
+      include Contracts
+
+      # Change the absolute x, y coordinates of the shape.
+      Contract Num, Num => Any
+      def [](x, y)
+        @x, @y = x, y
+        self
+      end
+
+      # Get the x, y coordinates of the shape.
+      Contract None => Coords
+      def at
+        [@x, @y]
+      end
+
+      # Move the shape relatively.
+      Contract Num, Num => Any
+      def move(x, y)
+        shape = clone
+        shape[shape.at[0] + x, shape.at[1] + y]
+        shape
+      end
+    end
+  end
+end

data/lib/vector_salad/shape_proxy.rb

@@ -0,0 +1,14 @@
+module VectorSalad
+  class ShapeProxy
+    attr_reader :shape
+
+    def initialize(shape)
+      @shape = shape
+    end
+
+    def method_missing(name, *args, &block)
+      @shape = shape.send(name, *args, &block)
+      self
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/basic_shape.rb

@@ -0,0 +1,29 @@
+require 'forwardable'
+require 'contracts'
+require 'contracts_contracts'
+
+module VectorSalad
+  module StandardShapes
+    class BasicShape
+      extend Forwardable
+      include Contracts
+
+      attr_accessor :options
+
+      delegate [
+        :flip,
+        :flip_x,
+        :flip_y,
+        :rotate,
+        :move,
+        :jitter,
+        :scale,
+        :to_simple_path,
+        :to_bezier_path,
+        :to_cubic_path,
+        :to_multi_path,
+        :to_a
+      ] => :to_path
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/circle.rb

@@ -0,0 +1,64 @@
+require "vector_salad/standard_shapes/path"
+require "vector_salad/standard_shapes/n"
+require "vector_salad/mixins/at"
+
+module VectorSalad
+  module StandardShapes
+    class Circle < Path
+      include VectorSalad::Mixins::At
+      attr_reader :radius
+
+      # Create a perfectly round circle.
+      #
+      # Examples do
+      #   new(100)
+      Contract Pos, {} => Circle
+      def initialize(radius, **options)
+        @options = options
+        @radius = radius
+        @x, @y = 0, 0
+        self
+      end
+
+      def to_path
+        # http://stackoverflow.com/a/13338311
+        # c = 4 * (Math.sqrt(2) - 1) / 3
+        # c = 0.5522847498307936
+        #
+        # http://spencermortensen.com/articles/bezier-circle/
+        c = 0.551915024494
+        d = c * @radius
+        Path.new(
+          N.n(@x + @radius, @y),
+          N.c(@x + @radius, @y + d),
+          N.c(@x + d, @y + @radius),
+          N.n(@x, @y + @radius),
+          N.c(@x - d, @y + @radius),
+          N.c(@x - @radius, @y + d),
+          N.n(@x - @radius, @y),
+          N.c(@x - @radius, @y - d),
+          N.c(@x - d, @y - @radius),
+          N.n(@x, @y - @radius),
+          N.c(@x + d, @y - @radius),
+          N.c(@x + @radius, @y - d),
+          N.n(@x + @radius, @y),
+          **@options
+        )
+      end
+
+      def to_simple_path(fn = nil)
+        fn ||= (@radius * 2).ceil
+
+        nodes = []
+        arc = (2.0 * Math::PI) / fn
+        fn.times do |t|
+          a = arc * t
+          x = @radius * Math.cos(a) + @x
+          y = @radius * Math.sin(a) + @y
+          nodes << N.n(x, y)
+        end
+        Path.new(*nodes, **@options)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/clip.rb

@@ -0,0 +1,51 @@
+require 'clipper'
+
+require 'vector_salad/dsl'
+require 'vector_salad/canvas'
+require 'vector_salad/standard_shapes/multi_path'
+
+module VectorSalad
+  module StandardShapes
+    class Clip < BasicShape
+      include VectorSalad::DSL
+      include VectorSalad::StandardShapes
+
+      # Perform a clipping operation on a set of paths or shapes.
+      # The first path is used as the subject, subsequent paths are applied to
+      # the first using the specified operation.
+      #
+      # It's easier to use one of the subclasses;
+      # (see {Difference}, {Intersection}, {Union}, {Exclusion}).
+      Contract Or[*%i(difference intersection union xor)], {}, Proc => MultiPath
+      def initialize(operation, **options, &block)
+        instance_eval(&block) # canvas is populated
+
+        clipper = Clipper::Clipper.new
+
+        i = 0
+        canvas.each do |shape|
+          method = i == 0 ? 'subject' : 'clip'
+          path = shape.to_simple_path.to_a
+          if path[0][0].instance_of? Array # MultiPath
+            clipper.send("add_#{method}_polygons".to_sym, path)
+          else # Path
+            clipper.send("add_#{method}_polygon".to_sym, path)
+          end
+          i += 1
+        end
+
+        @path = MultiPath.new(
+          *clipper.send(operation, :non_zero, :non_zero), **options
+        )
+      end
+
+      def canvas
+        @canvas ||= VectorSalad::Canvas.new
+      end
+
+      def to_path
+        @path
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/custom.rb

@@ -0,0 +1,28 @@
+require 'vector_salad/standard_shapes/path'
+require 'vector_salad/standard_shapes/n'
+require 'vector_salad/dsl'
+require 'vector_salad/canvas'
+
+module VectorSalad
+  module StandardShapes
+    class Custom < BasicShape
+      def initialize(name, &block)
+        #instance_eval(&block)
+        ::VectorSalad::StandardShapes.const_set(name.to_s.capitalize.to_sym, Class.new(BasicShape) do
+          include VectorSalad::DSL
+          include VectorSalad::StandardShapes
+
+          define_method(:initialize, &block)
+
+          def canvas
+            @canvas ||= VectorSalad::Canvas.new
+          end
+
+          def to_path
+            canvas[0]
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/difference.rb

@@ -0,0 +1,28 @@
+require 'vector_salad/standard_shapes/clip'
+require 'vector_salad/standard_shapes/multi_path'
+
+module VectorSalad
+  module StandardShapes
+    class Difference < Clip
+      # Subtract paths.
+      # The first path is used as the subject, subsequent paths are subtracted
+      # from the first.
+      #
+      # Examples:
+      #
+      #   Difference.new do
+      #     canvas << Path.new([0,0], [90,90], [0,90])
+      #     canvas << Path.new([50,0], [95,0], [50, 70])
+      #   end
+      #
+      #   # Using DSL:
+      #   difference do
+      #     path([0,0], [90,90], [0,90])
+      #     path([50,0], [95,0], [50, 70])
+      #   end
+      def initialize(**options, &block)
+        super(:difference, **options, &block)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/exclusion.rb

@@ -0,0 +1,28 @@
+require 'vector_salad/standard_shapes/clip'
+require 'vector_salad/standard_shapes/multi_path'
+
+module VectorSalad
+  module StandardShapes
+    class Exclusion < Clip
+      # Exclude paths.
+      # The first path is used as the subject, subsequent paths are excluded
+      # from the first.
+      #
+      # Examples:
+      #
+      #   Exclusion.new do
+      #     canvas << Path.new([0,0], [90,90], [0,90])
+      #     canvas << Path.new([50,0], [95,0], [50, 70])
+      #   end
+      #
+      #   # Using DSL:
+      #   exclusion do
+      #     path([0,0], [90,90], [0,90])
+      #     path([50,0], [95,0], [50, 70])
+      #   end
+      def initialize(**options, &block)
+        super(:xor, **options, &block)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/flip.rb

@@ -0,0 +1,24 @@
+require 'vector_salad/standard_shapes/transform'
+
+module VectorSalad
+  module StandardShapes
+    class Flip < Transform
+      # Flip the contained shapes on the specified axis.
+      #
+      # Examples:
+      #
+      #   flip(:x) do
+      #     triangle(30, at: [50, -50])
+      #     pentagon(40, at: [50, -100])
+      #   end
+      Contract Or[:x, :y], { canvas: VectorSalad::Canvas }, Proc => Any
+      def initialize(axis, canvas:, **_options, &block)
+        instance_eval(&block) # inner_canvas is populated
+
+        @canvas.each do |shape|
+          canvas << shape.flip(axis)
+        end
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/hexagon.rb

@@ -0,0 +1,15 @@
+require 'vector_salad/standard_shapes/polygon'
+
+module VectorSalad
+  module StandardShapes
+    class Hexagon < Polygon
+      # Create a regular hexagon.
+      #
+      # Examples:
+      #   new(100)
+      def initialize(radius, **options)
+        super(6, radius, **options)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/intersection.rb

@@ -0,0 +1,28 @@
+require 'vector_salad/standard_shapes/clip'
+require 'vector_salad/standard_shapes/multi_path'
+
+module VectorSalad
+  module StandardShapes
+    class Intersection < Clip
+      # Intersect paths.
+      # The first path is used as the subject, subsequent paths are intersected
+      # with the first.
+      #
+      # Examples:
+      #
+      #   Intersection.new do
+      #     canvas << Path.new([0,0], [90,90], [0,90])
+      #     canvas << Path.new([50,0], [95,0], [50, 70])
+      #   end
+      #
+      #   # Using DSL:
+      #   intersection do
+      #     path([0,0], [90,90], [0,90])
+      #     path([50,0], [95,0], [50, 70])
+      #   end
+      def initialize(**options, &block)
+        super(:intersection, **options, &block)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/iso_tri.rb

@@ -0,0 +1,39 @@
+require "vector_salad/standard_shapes/path"
+require "vector_salad/standard_shapes/n"
+require "vector_salad/mixins/at"
+
+module VectorSalad
+  module StandardShapes
+    class IsoTri < BasicShape
+      include VectorSalad::Mixins::At
+
+      attr_reader :height
+
+      # Create an isosceles or right-angle triangle.
+      #
+      # Examples:
+      #
+      #   new(100)
+      #   new(100, 150)
+      #
+      # @param width (defaults to height*2).
+      Contract Args[Pos], {} => IsoTri
+      def initialize(width = nil, height, **options)
+        width = height * 2 if width.nil?
+        @width, @height = width, height
+        @options = options
+        @x, @y = 0, 0
+        self
+      end
+
+      def to_path
+        Path.new(
+          N.n(@x, @y),
+          N.n(@x - @width / 2, @y + @height),
+          N.n(@x + @width / 2, @y + @height),
+          **@options
+        )
+      end
+    end
+  end
+end