svgcode 0.2.0

data/lib/svgcode/gcode/command.rb

@@ -0,0 +1,141 @@
+module Svgcode
+  module GCode
+    class Command
+      INT_FORMAT = "%02d"
+      FLOAT_FORMAT = "%.3f"
+      INT_LETTERS = [ 'M', 'G' ]
+
+      attr_reader :letter, :number, :args
+
+      def initialize(letter_or_str = nil, number = nil, args = [])
+        if letter_or_str.length > 1
+          parts = letter_or_str.split(/\s+/)
+          cmd = Command.parse_single(parts.shift)
+          @letter = cmd.letter
+          @number = cmd.number
+          @args = parts.collect { |arg| Command.parse_single(arg) }        
+        else
+          @letter = letter_or_str
+          @number = number
+          @args = args
+        end
+
+        @letter = @letter.to_s.upcase
+        @number = @number.to_f unless @number.nil?
+      end
+
+      def to_s
+        num_fmt = INT_LETTERS.include?(@letter) ? INT_FORMAT : FLOAT_FORMAT
+        str = "#{@letter}#{num_fmt % @number}"
+        str += " #{@args.join(' ')}" unless @args.nil? || @args.empty?
+        str
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && 
+          other.letter == @letter &&
+          other.number.eql?(@number) &&
+          other.args == @args
+      end
+
+      def roughly_equal?(other)
+        return false unless @letter == other.letter
+        return false unless @args.length == other.args.length
+        return @number == other.number unless @number.nil? || other.number.nil?
+
+        result = true
+        @args.each_with_index do |arg, i|
+          unless arg.roughly_equal?(other.args[i])
+            result = false
+            break
+          end
+        end
+
+        result
+      end
+
+      def self.parse_single(str)
+        letter = str[0].to_sym
+        number = str.length > 1 ? str[1..(str.length - 1)] : nil
+        Command.new(letter, number)
+      end
+
+      def self.comment(str)
+        "\n(#{str}!!!)"
+      end
+
+      def self.absolute
+        Command.new(:g, 90)
+      end
+
+      def self.relative
+        Command.new(:g, 91)
+      end
+
+      def self.metric
+        Command.new(:g, 21)
+      end
+
+      def self.imperial
+        Command.new(:g, 20)
+      end
+
+      def self.home
+        Command.new(:g, 30)
+      end
+
+      def self.stop
+        Command.new(:m, 2)
+      end
+
+      def self.feedrate(rate)
+        Command.new(:f, rate)
+      end
+
+      def self.go(x, y)
+        Command.new(:g, 0, [
+          Command.new(:x, x),
+          Command.new(:y, y)
+        ])
+      end
+
+      def self.cut(x, y)
+        Command.new(:g, 1, [
+          Command.new(:x, x),
+          Command.new(:y, y)
+        ])
+      end
+
+      def self.cubic_spline(i, j, _p, q, x, y)
+        Command.new(:g, 5, [
+          Command.new(:i, i),
+          Command.new(:j, j),
+          Command.new(:p, _p),
+          Command.new(:q, q),
+          Command.new(:x, x),
+          Command.new(:y, y)
+        ])
+      end
+
+      def self.clear(clearance)
+        Command.new(:g, 0, [
+          Command.new(:z, clearance)
+        ])
+      end
+
+      def self.plunge(depth)
+        Command.new(:g, 1, [
+          Command.new(:z, depth)
+        ])
+      end
+
+      def self.g(number, args = nil)
+        Command.new(:g, number, args)
+      end
+
+      def self.m(number, args = nil)
+        Command.new(:m, number, args)
+      end
+    end
+  end
+end

data/lib/svgcode/gcode/converter.rb

@@ -0,0 +1,97 @@
+require 'svgcode/gcode/program'
+require 'svgcode/svg/path'
+
+module Svgcode
+  module GCode
+    class Converter
+      PX_PER_INCH = 300
+      PX_PER_MM = PX_PER_INCH / 25.4
+
+      attr_accessor :transforms
+      attr_reader :program, :finished, :metric, :max_y
+
+      def initialize(opts)
+        raise ArgumentError.new if opts.nil? || opts[:max_y].nil?
+        @finished = false
+        @transforms = []
+        @max_y = opts.delete(:max_y)
+        @program = Program.new(opts)
+        @metric = opts[:metric] != false
+        @metric ? @program.metric! : @program.imperial!
+        @program.feedrate!
+      end
+
+      def <<(svg_d)
+        svg_start = nil
+        path = SVG::Path.new(svg_d)
+        start = nil
+
+        path.commands.each do |cmd|
+          cmd.apply_transforms!(@transforms)
+          cmd.absolute? ? cmd.flip_points_y!(@max_y) : cmd.negate_points_y!
+
+          if metric?
+            cmd.divide_points_by!(PX_PER_MM)
+          else
+            cmd.divide_points_by!(PX_PER_INCH)
+          end
+
+          if (cmd.name == :close || cmd.absolute?) && @program.relative?
+            @program.absolute!
+          elsif cmd.relative? && @program.absolute?
+            @program.relative!
+          end
+
+          case cmd.name
+          when :move
+            start = cmd.relative? ? cmd.absolute(@program.pos) : cmd
+            @program.go!(cmd.points.first.x, cmd.points.first.y)
+          when :line
+            @program.cut!(cmd.points.first.x, cmd.points.first.y)
+          when :cubic
+            cubic!(cmd)
+          when :close
+            @program.cut!(start.points.first.x, start.points.first.y)
+            start = nil
+          end
+        end
+      end
+
+      def metric?
+        @metric
+      end
+
+      def comment!(str)
+        @program.comment!(str)
+      end
+
+      def finish
+        unless @finished
+          @program.home!
+          @program.stop!
+          @finished = true
+        end
+      end
+
+      def to_s
+        @program.to_s
+      end
+
+      private
+
+      def cubic!(cmd)
+        # A relative SVG cubic bezier has all control points relative to start.
+        # G-code I&J are relative to start, and P&Q relative to end.
+        # I, J, P & Q are always relative, but SVG values can be absolute.
+        cmd.points[0] -= @program.pos if cmd.absolute?
+        cmd.points[1] -= cmd.points[2]
+
+        @program.cubic_spline!(
+          cmd.points[0].x, cmd.points[0].y,
+          cmd.points[1].x, cmd.points[1].y,
+          cmd.points[2].x, cmd.points[2].y,
+        )
+      end
+    end
+  end
+end

data/lib/svgcode/gcode/invalid_command_error.rb

@@ -0,0 +1,6 @@
+module Svgcode
+  module GCode
+    class InvalidCommandError < StandardError
+    end
+  end
+end

data/lib/svgcode/gcode/program.rb

@@ -0,0 +1,199 @@
+require 'svgcode/gcode/command'
+require 'svgcode/gcode/invalid_command_error'
+
+module Svgcode
+  module GCode
+    class Program
+      DEFAULT_FEEDRATE = 120
+      DEFAULT_CLEARANCE = 5
+      DEFAULT_DEPTH = -0.5
+
+      attr_accessor :opts, :commands
+
+      # 3 states
+      # ========
+      # at Z home height:          @is_poised = false, @is_plunged = false
+      # at Z clearance height:     @is_poised = true,  @is_plunged = false
+      # at Z cutting depth height: @is_poised = true,  @is_plunged = true
+      attr_reader :is_plunged, :is_poised, :is_absolute, :x, :y
+
+      def initialize(opts = {})
+        @is_plunged = false
+        @is_poised = false
+        @commands = opts.delete(:commands) || []
+        @is_absolute = opts.delete(:absolute)
+        @is_absolute = true if @is_absolute.nil?
+
+        @opts = {
+          feedrate: DEFAULT_FEEDRATE,
+          clearance: DEFAULT_CLEARANCE,
+          depth: DEFAULT_DEPTH
+        }.merge(opts)
+      end
+
+      def feedrate
+        @opts[:feedrate]
+      end
+
+      def clearance
+        @opts[:clearance]
+      end
+
+      def depth
+        @opts[:depth]
+      end
+
+      def plunged?
+        @is_plunged
+      end
+
+      def poised?
+        @is_poised
+      end
+
+      def absolute?
+        @is_absolute
+      end
+
+      def relative?
+        @is_absolute.nil? ? nil : !@is_absolute
+      end
+
+      def <<(command)
+        if !command.is_a?(String) &&
+          (@x.nil? || @y.nil?) && 
+          command.letter == 'G' &&
+          command.number < 6 &&
+          command != Command.relative &&
+          command != Command.absolute
+        then
+          if relative?
+            raise InvalidCommandError.new(
+              'Cannot add a command when relative and @x or @y are nil'
+            )
+          else
+            @commands << Command.absolute
+          end
+        end
+
+        @commands << command
+      end
+
+      def comment!(str)
+        self << Command.comment(str)
+      end
+
+      def metric!
+        self << Command.metric
+      end
+
+      def imperial!
+        self << Command.imperial
+      end
+
+      def absolute!
+        unless absolute?
+          self << Command.absolute
+          @is_absolute = true
+        end
+      end
+
+      def relative!
+        unless relative?
+          self << Command.relative
+          @is_absolute = false
+        end
+      end
+
+      def feedrate!(rate = nil)
+        if rate.nil?
+          rate = feedrate
+        else
+          @opts[:feedrate] = rate
+        end
+
+        self << Command.feedrate(rate)
+      end
+
+      def stop!
+        self << Command.stop
+      end
+
+      def home!
+        clear! if plunged?
+        @commands.pop if @commands.last == Command.relative
+        self << Command.home if poised?
+        @x = nil
+        @y = nil
+        @is_poised = false
+      end
+
+      def clear!
+        temp_absolute { self << Command.clear(clearance) }
+        @is_plunged = false
+        @is_poised = true
+      end
+
+      def plunge!
+        clear! unless poised?
+        temp_absolute { self << Command.plunge(depth) }
+        @is_plunged = true
+      end
+
+      def go!(x, y)
+        clear! if plunged?
+        self << Command.go(x, y)
+        set_coords(x, y)
+      end
+
+      def cut!(x, y)
+        perform_cut(x, y) { self << Command.cut(x, y) }
+      end
+
+      def cubic_spline!(i, j, _p, q, x, y)
+        perform_cut(x, y) do
+          self << Command.cubic_spline(i, j, _p, q, x, y)
+        end
+      end
+
+      def pos
+        Svgcode::SVG::Point.new(@x, @y)
+      end
+
+      def to_s
+        @commands.join("\n")
+      end
+
+      private
+
+      def perform_cut(x, y)
+        plunge! unless plunged?
+        yield
+        set_coords(x, y)
+      end
+
+      def temp_absolute
+        was_relative = relative?
+
+        if @commands.last == Command.relative
+          @commands.pop
+          @is_absolute = true
+        end
+
+        absolute! if relative?
+        yield
+        relative! if was_relative
+      end
+
+      def set_coords(x, y)
+        if absolute?
+          @x = x
+          @y = y
+        else
+          @x += x
+          @y += y
+        end
+      end
+    end
+  end
+end

data/lib/svgcode/svg/command.rb

@@ -0,0 +1,109 @@
+require 'svgcode/svg/point'
+
+module Svgcode
+  module SVG
+    class Command
+      attr_reader :name, :absolute, :points
+
+      NAMES = {
+        'm' => :move,
+        'l' => :line,
+        'c' => :cubic,
+        'z' => :close
+      }
+
+      def initialize(str_or_opts)
+        if str_or_opts.is_a?(Hash)
+          @name = str_or_opts[:name]
+          @absolute = !!str_or_opts[:absolute]
+          @points = str_or_opts[:points]
+        else
+          str = str_or_opts
+          @name = NAMES[str[0].to_s.downcase]
+
+          @absolute =
+          if @name == :close
+            true
+          else
+            !!str[0].match(/[A-Z]/)
+          end
+
+          if @name != :close && str.length > 1
+            @points = Point.parse(str[1..(str.length - 1)])
+          end
+        end
+
+        @points = [] if @points.nil?
+      end
+
+      def absolute?
+        @absolute
+      end
+
+      def relative?
+        !@absolute
+      end
+
+      def absolute(pos)
+        points = @points.collect { |p| p + pos }
+        Command.new(name: @name, absolute: true, points: points)
+      end
+
+      def absolute!(pos)
+        if relative?
+          @points.collect! { |p| p + pos }
+          @absolute = true
+        end
+      end
+
+      def negate_points_y
+        points = @points.collect { |point| point.negate_y }
+        Command.new(name: @name, absolute: @absolute, points: points)
+      end
+
+      def negate_points_y!
+        @points.each { |point| point.negate_y! }
+        nil
+      end
+
+      def divide_points_by!(amount)
+        @points.each { |point| point.divide_by!(amount) }
+        nil
+      end
+
+      def flip_points_y!(max_y)
+        @points.each { |point| point.flip_y!(max_y) }
+        nil
+      end      
+
+      def apply_transforms!(transforms)
+        unless transforms.empty?
+          transforms.reverse.each do |transform|
+            @points.collect! { |point| transform.apply(point) }
+          end
+        end
+      end
+
+      def name_str
+        Command.name_str(@name, absolute?)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && 
+          other.name == @name && 
+          other.absolute? == @absolute && 
+          other.points == @points
+      end
+
+      def to_s
+        name_str + @points.collect { |p| p.to_s }.join(' ')
+      end
+
+      def self.name_str(sym, absolute)
+        str = NAMES.key(sym).dup
+        str.upcase! if absolute
+        str
+      end
+    end
+  end
+end

data/lib/svgcode/svg/path.rb

@@ -0,0 +1,13 @@
+require 'svgcode/svg/command'
+
+module Svgcode
+  module SVG
+    class Path
+      attr_reader :commands
+
+      def initialize(str)
+        @commands = str.split(/(?=[a-z])/i).collect { |s| Command.new(s) }
+      end
+    end
+  end
+end

data/lib/svgcode/svg/point.rb

@@ -0,0 +1,82 @@
+module Svgcode
+  module SVG
+    class Point
+      attr_reader :x, :y
+
+      VALUE_SEP = /\s?,\s?/
+      OBJECT_SEP = /\s+/
+
+      def initialize(str_or_x, y = nil)
+        if y.nil?
+          parts = str_or_x.split(VALUE_SEP)
+          @x = parts.first.to_f
+          @y = parts.last.to_f
+        else
+          @x = str_or_x.to_f
+          @y = y.to_f
+        end
+      end
+
+      def negate_y
+        Point.new(@x, -@y)
+      end
+
+      def negate_y!
+        @y = -@y
+      end
+
+      def +(point_or_num)
+        if point_or_num.is_a?(Point)
+          Point.new(@x + point_or_num.x, @y + point_or_num.y)
+        else
+          Point.new(@x + point_or_num, @y + point_or_num)
+        end
+      end
+
+      def -(point_or_num)
+        if point_or_num.is_a?(Point)
+          Point.new(@x - point_or_num.x, @y - point_or_num.y)
+        else
+          Point.new(@x - point_or_num, @y - point_or_num)
+        end
+      end
+
+      def *(point_or_num)
+        if point_or_num.is_a?(Point)
+          Point.new(@x / point_or_num.x, @y / point_or_num.y)
+        else
+          Point.new(@x / point_or_num, @y / point_or_num)
+        end
+      end
+
+      def /(point_or_num)
+        if point_or_num.is_a?(Point)
+          Point.new(@x / point_or_num.x, @y / point_or_num.y)
+        else
+          Point.new(@x / point_or_num, @y / point_or_num)
+        end
+      end
+
+      def divide_by!(amount)
+        @x /= amount
+        @y /= amount
+      end
+
+      def flip_y!(max_y)
+        @y = max_y - @y
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.x.eql?(@x) && other.y.eql?(@y)
+      end
+
+      def to_s
+        "#{@x},#{@y}"
+      end
+
+      def self.parse(str)
+        str.split(OBJECT_SEP).collect { |p| Point.new(p.strip) }
+      end
+    end
+  end
+end

data/lib/svgcode/svg/transform.rb

@@ -0,0 +1,52 @@
+require 'svgcode/svg/point'
+require 'matrix'
+
+module Svgcode
+  module SVG
+    class Transform
+      attr_reader :a, :b, :c, :d, :e, :f
+
+      def initialize(str_or_a, b = nil, c = nil, d = nil, e = nil, f = nil)
+        if str_or_a.is_a?(String)
+          raise ArgumentException.new unless str_or_a.start_with?('matrix')
+          nums = str_or_a.gsub(/.+\(/, '').gsub(/\)/, '').split(/\s*,\s*/)
+
+          nums.each_with_index do |n, i|
+            case i
+            when 0
+              @a = n.to_f
+            when 1
+              @b = n.to_f
+            when 2
+              @c = n.to_f
+            when 3
+              @d = n.to_f
+            when 4
+              @e = n.to_f
+            when 5
+              @f = n.to_f
+            end
+          end
+        else
+          @a = str_or_a.to_f
+          @b = b.to_f
+          @c = c.to_f
+          @d = d.to_f
+          @e = e.to_f
+          @f = f.to_f
+        end
+      end
+
+      def to_matrix
+        Matrix[[@a, @c, @e], [@b, @d, @f], [0, 0, 1]]
+      end
+
+      def apply(point)
+        point_m = Matrix[[point.x], [point.y], [1]]
+        transform_m = to_matrix
+        result = transform_m * point_m
+        Point.new(result[0, 0], result[1, 0])
+      end
+    end
+  end
+end

data/lib/svgcode/version.rb

@@ -0,0 +1,3 @@
+module Svgcode
+  VERSION = '0.2.0'
+end