vector_salad 0.0.1

data/lib/vector_salad/standard_shapes/jitter.rb

@@ -0,0 +1,33 @@
+require 'vector_salad/standard_shapes/transform'
+
+module VectorSalad
+  module StandardShapes
+    class Jitter < Transform
+      # Moves the contained shapes by the specified x and y amounts relatively.
+      #
+      # Examples:
+      #
+      #   move(50, -10) do
+      #     triangle(30, at: [50, -50])
+      #     pentagon(40, at: [50, -100])
+      #   end
+
+      # Jitter the position of nodes in a Path randomly.
+      # @param max The maximum offset
+      # @param min The minimum offset (default 0)
+      # @param fn The quantization number of sides
+      Contract Num, { min: Maybe[Num], fn: Maybe[Fixnum] } => Path
+      Contract Num, { min: Maybe[Num],
+                      fn: Maybe[Fixnum],
+                      canvas: VectorSalad::Canvas
+                    }, Proc => Any
+      def initialize(max, min: 0, fn: nil, canvas:, **_options, &block)
+        instance_eval(&block) # inner_canvas is populated
+
+        @canvas.each do |shape|
+          canvas << shape.jitter(max, min: min, fn: fn)
+        end
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/move.rb

@@ -0,0 +1,24 @@
+require "vector_salad/standard_shapes/transform"
+
+module VectorSalad
+  module StandardShapes
+    class Move < Transform
+      # Moves the contained shapes by the specified x and y amounts relatively.
+      #
+      # Examples:
+      #
+      #   move(50, -10) do
+      #     triangle(30, at: [50, -50])
+      #     pentagon(40, at: [50, -100])
+      #   end
+      Contract Coord, Coord, { canvas: VectorSalad::Canvas }, Proc => Any
+      def initialize(x, y, canvas:, **_options, &block)
+        instance_eval(&block) # inner_canvas is populated
+
+        @canvas.each do |shape|
+          canvas << shape.move(x, y)
+        end
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/multi_path.rb

@@ -0,0 +1,82 @@
+require 'vector_salad/standard_shapes/basic_shape'
+require 'vector_salad/standard_shapes/n'
+require 'vector_salad/interpolate'
+
+module VectorSalad
+  module StandardShapes
+    class MultiPath < BasicShape
+      attr_reader :paths, :closed
+
+      # A MultiPath is a collection of Paths.
+      # It is mainly the result of {Clip} operations.
+      # See {Path} for details on constructing paths.
+      #
+      # Examples:
+      #   new(
+      #     Path.n([0,0], [0,300], [300,300], [300,0], [0,0]),
+      #     Path.n([100,100], [200,100], [200,200], [100,200], [100,100])
+      #   )
+      #   new(
+      #     [[0,0], [0,300], [300,300], [300,0], [0,0]],
+      #     [[100,100], [200,100], [200,200], [100,200], [100,100]]
+      #   )
+      Contract Args[Or[Array, Path]], { closed: Maybe[Bool] } => MultiPath
+      def initialize(*paths, closed: true, **options)
+        paths.each do |path|
+          path = path.instance_of?(Array) ? Path.new(*path) : path
+          @paths = Array(@paths) << path
+        end
+
+        @closed = closed
+        @options = options
+        self
+      end
+
+      # Move the shape relatively.
+      Contract Num, Num => MultiPath
+      def move(x, y)
+        each_send(:move, x, y)
+      end
+
+      # Rotates the MultiPath by the specified angle about the origin.
+      Contract Num => MultiPath
+      def rotate(angle)
+        each_send(:rotate, angle)
+      end
+
+      # Scale a MultiPath by multiplier about the origin.
+      Contract Num => MultiPath
+      def scale(multiplier)
+        each_send(:scale, multiplier)
+      end
+
+      def to_path
+        self
+      end
+
+      def to_cubic_path
+        self.class.new(*@paths.map(&:to_cubic_path), **@options)
+      end
+
+      def to_simple_path
+        self.class.new(*@paths.map(&:to_simple_path), **@options)
+      end
+
+      def to_multi_path
+        self
+      end
+
+      def to_a
+        @paths.map(&:to_a)
+      end
+
+      private
+
+      def each_send(method, *args, &block)
+        self.class.new(*@paths.map do |path|
+          path.send(method, *args, &block)
+        end, closed: @closed, **@options)
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/n.rb

@@ -0,0 +1,112 @@
+require "vector_salad/mixins/at"
+
+module VectorSalad
+  module StandardShapes
+    class N
+      include VectorSalad::Mixins::At
+      include Contracts
+
+      attr_accessor :x, :y, :type
+
+      Contract nil, nil, :mirror => N
+      def initialize(x, y, type)
+        create(x, y, type)
+        self
+      end
+
+      # A node is the simplest primitive but useless on its own. Use nodes to
+      # build up a path (see Path). A node is a point in space with x and y
+      # coordinates. The coordinates must be nil if the node type is :mirror,
+      # else they must be numeric.
+      #
+      # A node also has a type, the simplest is :node for corners.
+      # To create node types other than :node see the shorthand class methods.
+      #
+      # Examples:
+      #   new(50, 100)
+      #   new(50, 100, :cubic)
+      #   new(nil, nil, :mirror)
+      Contract Coord, Coord,
+               Maybe[*%i(node quadratic cubic g2 g4 left right)] => N
+      def initialize(x, y, type = :node)
+        create(x, y, type)
+        self
+      end
+
+      # Shorthand for calling `new` to create a node.
+      # The type defaults to :node for basic corner or line segment nodes.
+      # See the documentation for `new` for usage.
+      Contract Maybe[Coord], Maybe[Coord], Maybe[Symbol] => N
+      def self.n(x, y, type = :node)
+        new(x, y, type)
+      end
+
+      # Creates a :mirrored type node. It makes it easier to make smooth curves.
+      # The reflection is based on the cubic or quadratic node
+      # before the last standard :node so there must be one.
+      Contract None => N
+      def self.m
+        new(nil, nil, :mirror)
+      end
+
+      # Shorthand that creates a :cubic type bezier curve handle node.
+      # This "off curve" node isn't part of the path but distorts pulling it.
+      # Two :cubic nodes must come between two :node type nodes. E.g. n c c n.
+      # As the interaction of two cubic nodes distorts the line segment this
+      # can be quite difficult to imagine, see :quadratic or :spiro for
+      # easier alternatives to make curves.
+      Contract Coord, Coord => N
+      def self.c(x, y)
+        new(x, y, :cubic)
+      end
+
+      # Shorthand that creates a :quadratic type bezier curve handle node.
+      # This "off curve" node isn't part of the path but distorts pulling it.
+      # One :quadratic node must come between two :node type nodes. E.g. n q n.
+      # Only one quadratic node is needed to make a curve, however :spiro type
+      # nodes are even easier for making smooth curves.
+      Contract Coord, Coord => N
+      def self.q(x, y)
+        new(x, y, :quadratic)
+      end
+
+      # Shorthand that creates a smooth spiro :g2 node.
+      # Spiro nodes are "on curve" so the path bends through them, finding the
+      # smoothest possible route. They are perfect for making organic curves.
+      # There are :g2 and :g4 spiro node types;
+      # :g2 is most robust and a good all rounder.
+      Contract Coord, Coord => N
+      def self.s(x, y)
+        new(x, y, :g2)
+      end
+
+      # Shorthand that creates a smooth spiro :g4 node.
+      # There are :g2 and :g4 spiro node types;
+      # :g4 is smoothest but has longer distance effects and may sometimes fail.
+      Contract Coord, Coord => N
+      def self.g(x, y)
+        new(x, y, :g4)
+      end
+
+      # Shorthand that creates a :right spiro node.
+      # It joins a straight line segment on the left to a curve on the right.
+      Contract Coord, Coord => N
+      def self.r(x, y)
+        new(x, y, :right)
+      end
+
+      # Shorthand that creates a :left spiro node.
+      # It joins a straight line segment on the right to a curve on the left.
+      Contract Coord, Coord => N
+      def self.l(x, y)
+        new(x, y, :left)
+      end
+
+      private
+
+      def create(x, y, type)
+        @x, @y, @type = x, y, type
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/oval.rb

@@ -0,0 +1,51 @@
+require "vector_salad/standard_shapes/path"
+require "vector_salad/standard_shapes/n"
+require "vector_salad/mixins/at"
+
+module VectorSalad
+  module StandardShapes
+    class Oval < BasicShape
+      include VectorSalad::Mixins::At
+      attr_reader :width, :height
+
+      # Create an oval.
+      #
+      # Examples:
+      #   new(100, 200)
+      Contract Pos, Pos, {} => Oval
+      def initialize(width, height, **options)
+        @options = options
+        @width, @height = width, height
+        @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
+        dw = c * @width
+        dh = c * @height
+        Path.new(
+          N.n(@x + @width, @y),
+          N.c(@x + @width, @y + dh),
+          N.c(@x + dw, @y + @height),
+          N.n(@x, @y + @height),
+          N.c(@x - dw, @y + @height),
+          N.c(@x - @width, @y + dh),
+          N.n(@x - @width, @y),
+          N.c(@x - @width, @y - dh),
+          N.c(@x - dw, @y - @height),
+          N.n(@x, @y - @height),
+          N.c(@x + dw, @y - @height),
+          N.c(@x + @width, @y - dh),
+          N.n(@x + @width, @y),
+          @options
+        )
+      end
+    end
+  end
+end

data/lib/vector_salad/standard_shapes/path.rb

@@ -0,0 +1,249 @@
+require 'spiro'
+
+require 'vector_salad/standard_shapes/basic_shape'
+require 'vector_salad/standard_shapes/n'
+require 'vector_salad/interpolate'
+
+module VectorSalad
+  module StandardShapes
+    class Path < BasicShape
+      attr_reader :nodes, :closed
+
+      # The simplest shape primitive, all shapes can be represented as a Path.
+      # A path is made up of N nodes and these nodes can have different types
+      # (see N).
+      #
+      # Examples:
+      #   new([0,0], [0,1], [1,1])
+      #
+      # @param nodes x,y coordinate arrays or N node instances
+      # @param closed whether the path is open or closed
+      Contract Args[Or[Array, N]], { closed: Maybe[Bool] } => Path
+      def initialize(*nodes, closed: true, **options)
+        @nodes = []
+        nodes.each_index do |i|
+          node = nodes[i].class == Array ? N.new(*nodes[i]) : nodes[i]
+          if i == 0 && ![:node, :g2, :g4, :left, :right].include?(node.type)
+            fail 'First node in a path must be :node or :spiro type.'
+          end
+          case node.type
+          when :cubic
+            unless nodes[i - 1].type == :node ||
+                  (nodes[i - 2].type == :node && nodes[i - 1].type == :cubic)
+              fail ':cubic nodes must follow a :node and at most 1 other :cubic.'
+            end
+          when :quadratic
+            unless nodes[i - 1].type == :node
+              fail ':quadratic nodes must follow a :node.'
+            end
+          when :mirror
+            if nodes[i - 1].type == :node &&
+               (nodes[i - 2].type == :quadratic || nodes[i - 2].type == :cubic)
+              pivot = nodes[i - 1]
+              source = nodes[i - 2]
+
+              dx = pivot.x - source.x
+              dy = pivot.y - source.y
+              node[pivot.x + dx, pivot.y + dy]
+
+              node.type = source.type
+            else
+              fail ':reflect nodes must be preceeded by a :node with a
+                :quadratic or :cubic before that.'
+            end
+          when :node
+          end
+          @nodes << node
+        end
+
+        @closed = closed
+        @options = options
+        self
+      end
+
+      # Move the shape relatively.
+      Contract Num, Num => Path
+      def move(x, y)
+        Path.new(
+          *to_path.nodes.map do |node|
+            node.move(x, y)
+          end,
+          closed: @closed,
+          **@options
+        )
+      end
+
+      # Flips on the x axis.
+      Contract None => Path
+      def flip_x
+        flip(:x)
+      end
+
+      # Flips on the y axis.
+      Contract None => Path
+      def flip_y
+        flip(:y)
+      end
+
+      # Flips the path on the specified axis.
+      #
+      # Examples:
+      #   flip(:x)
+      #   flip(:y)
+      Contract Or[:x, :y] => Path
+      def flip(axis)
+        x = axis == :y ? -1 : 1
+        y = axis == :x ? -1 : 1
+
+        Path.new(
+          *to_path.nodes.map { |n| N.new(n.x * x, n.y * y, n.type) },
+          closed: @closed, **@options
+        )
+      end
+
+      # Rotates the Path by the specified angle about the origin.
+      # Examples:
+      #   rotate(90)
+      #   rotate(-45)
+      Contract Num => Path
+      def rotate(angle)
+        theta = angle / 180.0 * Math::PI
+
+        # http://stackoverflow.com/a/786508
+        # p'x = cos(theta) * (px-ox) - sin(theta) * (py-oy) + ox
+        # p'y = sin(theta) * (px-ox) + cos(theta) * (py-oy) + oy
+        Path.new(
+          *to_path.nodes.map do |n|
+            N.new(
+              Math.cos(theta) * n.x - Math.sin(theta) * n.y,
+              Math.sin(theta) * n.x + Math.cos(theta) * n.y,
+              n.type
+            )
+          end, closed: @closed, **@options
+        )
+      end
+
+      # Scale a Path by multiplier about the origin.
+      # Supply just 1 multiplier to scale evenly, or x and y multipliers
+      # to stretch or squash the axies.
+      # @param x_multiplier 1 is no change, 2 is double size, 0.5 is half, etc.
+      Contract Num, Maybe[Num] => Path
+      def scale(x_multiplier, y_multiplier = x_multiplier)
+        Path.new(
+          *to_path.nodes.map do |n|
+            N.new(
+              n.x * x_multiplier,
+              n.y * y_multiplier,
+              n.type
+            )
+          end, closed: @closed, **@options
+        )
+      end
+
+      # Jitter the position of nodes in a Path randomly.
+      # @param max The maximum offset
+      # @param min The minimum offset (default 0)
+      # @param fn The quantization number of sides
+      Contract Num, { min: Maybe[Num], fn: Maybe[Fixnum] } => Path
+      def jitter(max, min: 0, fn: nil)
+        Path.new(
+          *to_simple_path(fn).nodes.map do |n|
+            r = Random.rand(min..max)
+            a = Random.rand(0..Math::PI * 2)
+            x = r * Math.cos(a)
+            y = r * Math.sin(a)
+            n.move(x, y)
+          end, closed: @closed, **@options
+        )
+      end
+
+      def to_path
+        self
+      end
+
+      def to_bezier_path
+        path = to_path
+        spiro = false
+        flat_path = path.nodes.map do |n|
+          spiro = true if spiro || [:g2, :g4, :left, :right].include?(n.type)
+          [n.x, n.y, n.type]
+        end
+        if spiro
+          flat_spline_path = Spiro.spiros_to_splines(flat_path, @closed)
+          if flat_spline_path.nil?
+            fail 'Spiro failed, try different coordinates or using G2 nodes.'
+          else
+            path = Path.new(*flat_spline_path.map do |n|
+              N.new(n[0], n[1], n[2])
+            end, closed: @closed, **@options)
+          end
+        end
+        path
+      end
+
+      def to_cubic_path
+        path = to_bezier_path.nodes
+        cubic_path = []
+        quadratic_last = false
+        path.each_index do |i|
+          n = path[i]
+          if quadratic_last
+            n0 = path[i - 2]
+            q  = path[i - 1]
+
+            # CP1 = QP0 + 2/3 * (QP1-QP0)
+            # CP2 = QP2 + 2/3 * (QP1-QP2)
+            third = 2 / 3.0
+            cubic_path << N.c(
+              n0.x + third * (q.x - n0.x),
+              n0.y + third * (q.y - n0.y)
+            )
+            cubic_path << N.c(
+              n.x + third * (q.x - n.x),
+              n.y + third * (q.y - n.y)
+            )
+            cubic_path << n
+
+            quadratic_last = false
+          elsif n.type == :quadratic
+            quadratic_last = true
+          else
+            cubic_path << n
+          end
+        end
+        Path.new(*cubic_path, closed: @closed, **@options)
+      end
+
+      def to_simple_path(*_)
+        # convert bezier curves and spiro splines
+        path = to_cubic_path.nodes
+
+        nodes = []
+        path.each_index do |i|
+          case path[i].type
+          when :node
+            if path[i - 1].type == :cubic
+              curve = path[i - 3..i].map(&:at)
+              nodes += VectorSalad::Interpolate.new.casteljau(curve)
+            else
+              nodes << path[i]
+            end
+          when :cubic
+          else
+            fail "Only :node and :cubic nodes in a path can be converted
+              to a simple path, was #{path[i].type}."
+          end
+        end
+        Path.new(*nodes, closed: @closed, **@options)
+      end
+
+      def to_multi_path
+        MultiPath.new(self)
+      end
+
+      def to_a
+        nodes.map(&:at)
+      end
+    end
+  end
+end