gerber 0 → 1

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in manufacturing.gemspec
+# Specify your gem's dependencies in gerber.gemspec
 gemspec

data/README.markdown

@@ -0,0 +1,42 @@
+# Gerber
+
+Everything you need to read and write Gerber RS-274-D and [Extended Gerber RS-274X](http://en.wikipedia.org/wiki/Gerber_Format) files
+
+Files created by this gem conform to the latest [Gerber format specification](http://www.ucamco.com/Portals/0/Public/The_Gerber_File_%20Format_Specification.pdf)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'gerber'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gerber
+
+## Usage
+
+```ruby
+require 'gerber'
+
+gerber = Gerber.read('somefile.gerber')
+gerber.write('outfile.gerber')
+```
+
+License
+-------
+
+Copyright 2012-2013 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
+
+
+## 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

data/Rakefile

@@ -1,2 +1,9 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.libs.push "lib"
+    t.test_files = FileList['test/**/*.rb']
+    t.verbose = true
+end

data/gerber.gemspec

@@ -2,16 +2,18 @@
 
 Gem::Specification.new do |gem|
   gem.name          = "gerber"
-  gem.version       = 0
+  gem.version       = 1
 
   gem.authors       = ["Brandon Fosdick"]
   gem.email         = ["bfoz@bfoz.net"]
   gem.description   = %q{Tools for working with Gerber and Extended Gerber files}
-  gem.summary       = %q{Everything you need to read and write Gerber RS-274-D and Extended Gerber RS-274-X files}
+  gem.summary       = %q{Everything you need to read and write Gerber RS-274-D and Extended Gerber RS-274X files}
   gem.homepage      = "http://github.com/bfoz/gerber"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_dependency  'geometry', '>= 6'
 end

data/lib/gerber.rb

@@ -1,3 +1,44 @@
-module Gerber
-  # Your code goes here...
+require 'geometry'
+require 'units'
+require_relative 'gerber/layer/parser'
+
+=begin
+Read and write {http://en.wikipedia.org/wiki/Gerber_Format Gerber} files (RS-274X)
+=end
+class Gerber
+    ParseError = Class.new(StandardError)
+
+    Arc = Geometry::Arc
+    Line = Geometry::Line
+    Point = Geometry::Point
+
+    attr_accessor :integer_places, :decimal_places
+    attr_accessor :zero_omission
+
+    attr_reader :apertures, :layers
+
+    def initialize
+	@apertures = []
+	@layers = []
+	@polarity = :positive
+	@units = nil
+    end
+
+    # Set the format used for coordinates
+    # @param [Number] integer_places	The number of digits to the left of the decimal point
+    # @param [Number] decimal_places	The number of digits to the right of the decimal point
+    def coordinate_format=(*args)
+	self.integer_places, self.decimal_places = args.flatten.map {|a| a.to_i }
+    end
+
+    # Read and parse the given file into a {Gerber} object
+    # @return [Gerber]	The resulting {Gerber} object, or nil on failure
+    def self.read(filename)
+	File.open(filename) do |f|
+	    Gerber::Parser.new.parse(f)
+	end
+    end
+
+    def self.write(filename, container)
+    end
 end

data/lib/gerber/aperture.rb

@@ -0,0 +1,34 @@
+require 'geometry'
+
+=begin
+An Aperture definition for an Extended {Gerber} file
+=end
+class Gerber
+    class Aperture
+	attr_reader :name, :shape
+	attr_accessor :hole, :parameters, :rotation
+
+	def initialize(parameters)
+	    raise ArgumentError unless parameters.is_a? Hash
+
+	    if parameters.has_key? :circle
+		@shape = Geometry::Circle.new [0,0], :diameter => parameters[:circle]
+		parameters.delete :circle
+	    elsif parameters.has_key? :obround
+		@shape = Geometry::Obround.new [0,0], parameters[:obround]
+		parameters.delete :obround
+	    elsif parameters.has_key? :polygon
+		@shape = Geometry::RegularPolygon.new parameters[:sides], [0,0], :diameter => parameters[:polygon]
+		parameters.delete :polygon
+	    elsif parameters.has_key? :rectangle
+		@shape = Geometry::Rectangle.new [0,0], parameters[:rectangle]
+		parameters.delete :rectangle
+	    end
+	    parameters.each {|k| self.instance_variable_set("@#{k.first}", k.last) }
+	end
+
+	def ==(other)
+	    (self.hole == other.hole) && (self.parameters == other.parameters) && (self.rotation == other.rotation) && (self.shape == other.shape)
+	end
+    end
+end

data/lib/gerber/layer.rb

@@ -0,0 +1,35 @@
+require 'gerber'
+require 'units'
+
+=begin
+A Gerber information layer (not to be confused with a PCB layer)
+=end
+class Gerber
+    class Layer
+	attr_accessor :geometry, :name, :polarity, :step, :repeat
+
+	def initialize(*args)
+	    super
+
+	    self.geometry = []
+	    @polarity = :dark
+	    @repeat = Vector[1,1]
+	    @step = Vector[0,0]
+	    @units = nil
+	end
+
+	# @group Accessors
+	def empty?
+	    self.geometry.empty?
+	end
+
+	def set_inches
+	    @units = 'inch'
+	end
+
+	def set_millimeters
+	    @units = 'millimeters'
+	end
+	# @endgroup
+    end
+end

data/lib/gerber/layer/parser.rb

@@ -0,0 +1,207 @@
+require 'gerber/layer'
+
+class Gerber
+    class Layer
+	class Parser
+	    DCodeError = Class.new(ParseError)
+
+	    attr_reader :current_aperture
+	    attr_reader :coordinate_mode
+	    attr_reader :layer
+	    attr_reader :position
+	    attr_reader :quadrant_mode
+
+	    def initialize(*args)
+		super
+
+		@coordinate_mode = :absolute
+		@dcode = 2	# off
+		@gcode = 1	# linear interpolation
+		@layer = Gerber::Layer.new
+		@position = Point[0,0]
+		@quadrant_mode = :single
+		@repeat = Vector[1,1]
+		@step = Vector[0,0]
+		@units = nil
+	    end
+
+	    def is_valid_geometry(arg)
+		arg.kind_of?(Line) || arg.kind_of?(Point) || arg.kind_of?(Arc)
+	    end
+
+	    def <<(arg)
+		raise ParseError, "Must set an aperture before generating geometry" unless self.current_aperture
+		self.layer.geometry[current_aperture] << arg if is_valid_geometry(arg)
+	    end
+
+	    # @group Accessors
+	    def current_aperture=(arg)
+		@current_aperture = arg
+		self.layer.geometry[arg] = [] unless self.layer.geometry[arg].is_a?(Array)
+	    end
+
+	    # @return [String]	The name of the current {Layer}
+	    def name
+		self.layer.name
+	    end
+
+	    # Set the name of the current {Layer}
+	    # @param [String] name  An ASCII string to set the name to
+	    def name=(name)
+		self.layer.name = name
+	    end
+
+	    # @return [Symbol]	The polarity setting of the current {Layer} (:dark or :clear)
+	    def polarity
+		self.layer.polarity
+	    end
+
+	    # Set the polarity of the current {Layer}
+	    # @param [Symbol] polarity	Set the current polarity to either :clear or :dark
+	    def polarity=(polarity)
+		self.layer.polarity = polarity
+	    end
+
+	    def set_inches
+		@units = 'inch'
+	    end
+
+	    def set_millimeters
+		@units = 'millimeters'
+	    end
+	    # @endgroup
+
+	    def parse_dcode(s)
+		/D(\d{2,3})/ =~ s
+		dcode = $1.to_i
+		case dcode
+		    when 1, 2, 3
+			@dcode = dcode
+		    when 10...999
+			self.current_aperture = dcode
+		    else
+			raise ParseError, "Invalid D Code #{dcode}"
+		end
+	    end
+
+	    def parse_gcode(gcode, x=nil, y=nil, i=nil, j=nil, dcode=nil)
+		gcode = gcode ? gcode.to_i : @gcode
+		dcode = dcode ? dcode.to_i : @dcode
+		case gcode
+		    when 1, 55  # G55 is deprecated, but behaves like G01
+			parse_g1(x, y, dcode)
+			@dcode = dcode
+			@gcode = gcode
+		    when 2
+			parse_g2(x, y, i, j, dcode)
+			@dcode = dcode
+			@gcode = gcode
+		    when 3
+			parse_g3(x, y, i, j, dcode)
+			@dcode = dcode
+			@gcode = gcode
+		    when 4  # G04 is used for single-line comments. Ignore the block and carry on.
+		    when 36
+			p "enable outline fill"
+		    when 37
+			p "disable outline fill"
+		    when 54
+			raise DCodeError, "G54 requires a D code (found #{x}, #{y}, #{dcode})" unless dcode
+			self.current_aperture = dcode.to_i
+		    when 70
+			set_inches
+		    when 71
+			set_millimeters
+		    when 74
+			@quadrant_mode = :single
+		    when 75
+			@quadrant_mode = :multi
+		    when 90
+			@coordinate_mode = :absolute
+		    when 91
+			@coordinate_mode = :incremental
+		    else
+			raise ParseError, "Unrecognized GCode #{gcode}"
+		end
+	    end
+
+	    def parse_g1(x, y, dcode)
+		point = Point[apply_units(x) || @position.x, apply_units(y) || @position.y]
+		case dcode
+		    when 1
+			line = Geometry::Line[@position, point]
+			self << line
+			@position = point
+		    when 2
+			@position = point
+		    when 3
+			self << point
+			@position = point
+		    else
+			raise DCodeError, "Invalid D parameter (#{dcode}) in G1"
+		end
+	    end
+
+	    def parse_g2(x, y, i, j, dcode)
+		raise DCodeError, "In G2 dcode must be either 1 or 2" unless [1, 2].include? dcode
+		if 1 == dcode
+		    x, y, i, j = [x, y, i, j].map {|a| apply_units(a)}
+		    startPoint = if self.quadrant_mode == :single
+			# start and end are swapped in clockwise mode (Geometry::Arc defaults to counterclockwise)
+			# i and j should have the same signs as the x and y components of the vector from the startpoint to the endpoint
+			if self.coordinate_mode == :absolute
+			    delta = Point[x, y] - @position
+			    i = i * (delta.x<=>0)
+			    j = j * (delta.y<=>0)
+			    Point[x, y]
+			elsif self.coordinate_mode == :incremental
+			    i = i * (x<=>0)
+			    j = j * (y<=>0)
+			    @position + Point[x, y]
+			end
+		    elsif @quadrant_mode == :multi
+			Point[x, y]
+		    else
+			raise ParseError, "Unrecognized quadrant mode: #{self.quadrant_mode}"
+		    end
+		    arc = Geometry::Arc.new(@position + Point[i, j], startPoint, @position)
+		    self << arc
+		    @position = arc.first
+		end
+	    end
+
+	    def parse_g3(x, y, i, j, dcode)
+		raise DCodeError, "In G3 dcode must be either 1 or 2" unless [1, 2].include? dcode
+		if 1 == dcode
+		    x, y, i, j = [x, y, i, j].map {|a| apply_units(a)}
+		    endPoint = if self.quadrant_mode == :single
+			# i and j should have the same signs as the x and y components of the vector from the startpoint to the endpoint
+			if self.coordinate_mode == :absolute
+			    delta = Point[x, y] - @position
+			    i = i * (delta.x<=>0)
+			    j = j * (delta.y<=>0)
+			    Point[x, y]
+			elsif self.coordinate_mode == :incremental
+			    i = i * (x<=>0)
+			    j = j * (y<=>0)
+			    @position + Point[x, y]
+			end
+		    elsif @quadrant_mode == :multi
+			Point[x, y]
+		    else
+			raise ParseError, "Unrecognized quadrant mode: #{self.quadrant_mode}"
+		    end
+		    arc = Geometry::Arc.new(@position + Point[i, j], @position, endPoint)
+		    self << arc
+		    @position = arc.last
+		end
+	    end
+
+	    def apply_units(a)
+		raise ParseError, "Units must be set before specifying coordinates" unless @units
+		return nil unless a
+		(@units == 'inch') ? a.inch : a.mm
+	    end
+	end
+    end
+end

data/lib/gerber/parser.rb

@@ -0,0 +1,275 @@
+require 'geometry'
+require 'gerber'
+require 'units'
+require_relative 'aperture'
+require_relative 'layer'
+require_relative 'layer/parser'
+
+class Gerber
+=begin
+Read and parse {http://en.wikipedia.org/wiki/Gerber_Format Gerber} files (RS-274X)
+=end
+    class Parser
+	attr_accessor :integer_places, :decimal_places
+	attr_accessor :zero_omission, :absolute
+
+	attr_reader :apertures, :layers
+	attr_reader :eof
+	attr_reader :total_places
+
+	def initialize
+	    @apertures = []
+	    @eof = false
+	    @layers = []
+	    @layer_parsers = []
+	    @axis_mirror = {:a => 1, :b => 1}   # 1 => not mirrored, -1 => mirrored
+	    @axis_select = {:a => :x, :b => :y}
+	    @offset = Point[0,0]
+	    @polarity = :positive
+	    @rotation = 0.degrees
+	    @scale = Vector[0,0]
+	    @symbol_mirror = {:a => 1, :b => 1} # 1 => not mirrored, -1 => mirrored
+	    @units = nil
+
+	    @new_layer_polarity = :dark
+	end
+
+	# Apply the configured units to a number
+	def apply_units(a)
+	    raise ParseError, "Units must be set before specifying dimensions" unless @units
+	    return nil unless a
+	    (@units == 'inch') ? a.inch : a.mm
+	end
+	private :apply_units
+
+	# Set the format used for coordinates
+	# @param [Number] integer_places	The number of digits to the left of the decimal point
+	# @param [Number] decimal_places	The number of digits to the right of the decimal point
+	def coordinate_format=(*args)
+	    self.integer_places, self.decimal_places = args.flatten.map {|a| a.to_i }
+	    @total_places = self.decimal_places + self.integer_places
+	end
+
+	# The {Layer} currently being parsed
+	def current_layer
+	    @layer_parsers.last || new_layer
+	end
+	private :current_layer
+
+	# Create and return a new {Layer::Parser}
+	def new_layer
+	    (@layer_parsers << Layer::Parser.new).last.polarity = @new_layer_polarity
+	    ('inch' == @units) ? @layer_parsers.last.set_inches : @layer_parsers.last.set_millimeters
+	    @layer_parsers.last
+	end
+
+	# Assume that all dimensions are in inches
+	def set_inches
+	    @units = 'inch'
+	    current_layer.set_inches
+	end
+
+	# Assume that all dimensions are in millimeters
+	def set_millimeters
+	    @units = 'millimeters'
+	    current_layer.set_millimeters
+	end
+
+	# Parse the given IO stream
+	# @param [IO] input	    An IO-like object to parse
+	def parse(input)
+	    input.each('*') do |block|
+		block.strip!
+		next if !block || block.empty?
+		raise ParseError, "Found blocks after M02" if self.eof
+		case block
+		    when /^%AM/ # Special handling for aperture macros
+			parse_parameter((block + input.gets('%')).gsub(/[\n%]/,''))
+		    when /^%[A-Z]{2}/
+			(block + input.gets('%')).gsub(/[\n%]/,'').gsub(/\* /,'').lines('*') {|b| parse_parameter(b)}
+		    when /^D(\d{2,3})/
+			current_layer.parse_dcode(block)
+		    when /^M0(0|1|2)/
+			mcode = $1
+			raise ParseError, "Invalid M code: #{m}" unless mcode
+			@eof = true if mcode.to_i == 2
+		    when /^G54D(\d{2,3})/	# Deprecated G54 function code
+			current_layer.parse_gcode(54, nil, nil, nil, nil, $1)
+		    when /^G70/
+			set_inches
+		    when /^G71/
+			set_millimeters
+		    when /^(G(\d{2}))?(X([\d\+-]+))?(Y([\d\+-]+))?(I([\d\+-]+))?(J([\d\+-]+))?(D0(1|2|3))?/
+			gcode, dcode = $2, $12
+			x, y, i, j = [$4, $6, $8, $10].map {|a| parse_coordinate(a) }
+			current_layer.parse_gcode(gcode, x, y, i, j, dcode)
+		    else
+			raise ParseError,"Unrecognized block: \"#{block}\""
+		end
+	    end
+
+	    # FIXME apply any @rotation
+
+	    @layers = @layer_parsers.map {|parser| parser.layer }.select {|layer| !layer.empty? }
+
+	    gerber = Gerber.new
+	    gerber.apertures.replace @apertures
+	    gerber.coordinate_format = self.integer_places, self.decimal_places
+	    gerber.layers.replace @layers
+	    gerber.zero_omission = self.zero_omission
+	    gerber
+	end
+
+	# Convert a string into a {Float} using the current coordinate formating setting
+	# @param [String] s	The string to convert
+	# @return [Float]	The resulting {Float}, or nil
+	def parse_coordinate(s)
+	    return nil unless s	# Ignore nil coordinates so that they can be handled later
+
+	    sign = s.start_with?('-') ? '-' : '+'
+	    s.sub!(sign,'')
+
+	    if s.length < total_places
+		if( zero_omission == :leading )
+		    s = s.rjust(total_places, '0')
+		elsif( zero_omission == :trailing )
+		    s = s.ljust(total_places, '0')
+		end
+	    end
+
+	    current_layer.apply_units((sign + s).insert(sign.length + integer_places, '.').to_f)
+	end
+
+	# Convert a string into a {Float} and apply the appropriate {Units}
+	# @param [String] s	    The string to convert
+	# @return [Float]	    The resulting {Float} with units, or nil
+	def parse_float(s)
+	    apply_units(s.to_f)
+	end
+
+	# Parse a set of parameter blocks
+	def parse_parameter(s)
+	    directive = s[0,2]
+	    case directive
+		when 'AD'	# Section 4.1
+		    dcode, type = s.match(/ADD(\d{2,3})(\w+)/).captures
+		    dcode = dcode.to_i
+		    raise ParseError unless (dcode >= 10) and (dcode <= 999)
+		    case type
+			when 'C'
+			    m = s.match(/C,(?<diameter>[\d.]+)(X(?<x>[\d.]+)(X(?<y>[\d.]+))?)?/)
+			    aperture = Aperture.new(:circle => parse_float(m[:diameter]))
+			    if( m[:x] )
+				x = parse_float(m[:x])
+				aperture.hole = m[:y] ? {:x => x, :y => parse_float(m[:y])} : x
+			    end
+
+			when 'R'
+			    m = s.match(/R,(?<x>[\d.]+)X(?<y>[\d.]+)(X(?<hole_x>[\d.]+)(X(?<hole_y>[\d.]+))?)?/)
+			    aperture = Aperture.new(:rectangle => [parse_float(m[:x]), parse_float(m[:y])])
+			    if( m[:hole_x] )
+				hole_x = parse_float(m[:hole_x])
+				aperture.hole = m[:hole_y] ? {:x => hole_x, :y => parse_float(m[:hole_y])} : hole_x
+			    end
+
+			when 'O'
+			    m = s.match(/O,(?<x>[\d.]+)X(?<y>[\d.]+)(X(?<hole_x>[\d.]+)(X(?<hole_y>[\d.]+))?)?/)
+			    aperture = Aperture.new(:obround => [parse_float(m[:x]), parse_float(m[:y])])
+			    if( m[:hole_x] )
+				hole_x = parse_float(m[:hole_x])
+				aperture.hole = m[:hole_y] ? {:x => hole_x, :y => parse_float(m[:hole_y])} : hole_x
+			    end
+
+			when 'P'
+			    m = s.match(/P,(?<diameter>[\d.]+)X(?<sides>[\d.]+)(X(?<rotation>[\d.]+)(X(?<hole_x>[\d.]+)(X(?<hole_y>[\d.]+))?)?)?/)
+			    aperture = Aperture.new(:polygon => parse_float(m[:diameter]), :sides => m[:sides].to_i)
+			    if( m[:rotation] )
+				aperture.rotation = m[:rotation].to_i.degrees
+				if( m[:hole_x] )
+				    hole_x = parse_float(m[:hole_x])
+				    aperture.hole = m[:hole_y] ? {:x => hole_x, :y => parse_float(m[:hole_y])} : hole_x
+				end
+			    end
+
+			else    # Special Aperture
+			    captures = s.match(/#{type}(,([\d.]+)(X([\d.]+))*)?/).captures
+			    parameters = captures.values_at(* captures.each_index.select {|i| i.odd?}).select {|p| p }
+			    aperture = Aperture.new(:name=>type)
+			    aperture.parameters = parameters.map {|p| parse_float(p) } if( parameters && (0 != parameters.size ) )
+		    end
+		    self.apertures[dcode] = aperture
+
+		# Section 4.2
+		when 'AM'
+    #		macro_name = block.match(/AM(\w*)\*/)[0]
+		    primitives = s.split '*'
+		    macro_name = primitives.shift.sub(/AM/,'')
+		    p "Aperature Macro: #{macro_name} => #{primitives}"
+		when 'SM'	# Deprecated
+		    /^SM(A(0|1))?(B(0|1))?/ =~ s
+		    @symbol_mirror[:a] = ('1' == $1) ? -1 : 1
+		    @symbol_mirror[:b] = ('1' == $2) ? -1 : 1
+
+		# Section 4.3 - Directive Parameters
+		when 'AS'	# Deprecated
+		    /^ASA(X|Y)B(X|Y)/ =~ s
+		    raise ParseError, "The AS directive requires that both axes must be specified" unless $1 && $2
+		    raise ParseError, "Axis Select directive can't map both data axes to the same output axis" if $1 == $2
+		    @axis_select[:a] = $1.downcase.to_sym
+		    @axis_select[:b] = $2.downcase.to_sym
+		when 'FS'
+		    /^FS(L|T)(A|I)(N\d)?(G\d)?X(\d)(\d)Y(\d)(\d)(D\d)?(M\d)?/ =~ s
+		    self.absolute = ($2 == 'A')
+		    self.zero_omission = ($1 == 'L') ? :leading : (($1 == 'T') ? :trailing : nil)
+		    xn, xm, yn, ym = $5, $6, $7, $8
+		    raise ParseError, "X and Y coordinate formats must equal" unless (xn == yn) && (xm == ym)
+		    self.coordinate_format = xn, xm
+		when 'MI'	# Deprecated
+		    /^MIA(0|1)B(0|1)/ =~ s
+		    raise ParseError, "The MI directive requires that both axes be specified" unless $1 || $2
+		    @axis_mirror[:a] = ('0' == $1) ? 1 : -1
+		    @axis_mirror[:b] = ('0' == $2) ? 1 : -1
+		when 'MO'
+		    /^MO(IN|MM)/ =~ s
+		    set_inches if 'IN' == $1
+		    set_millimeters if 'MM' == $1
+		when 'OF'	# Deprecated
+		    /^OF(A([\d.+-]+))?(B([\d.+-]+))?/ =~ s
+		    @offset = Point[parse_float($2) || 0.0, parse_float($4) || 0.0]
+		when 'SF'	# Deprecated
+		    /^SF(A([\d.+-]+))?(B([\d.+-]+))?/ =~ s
+		    @scale = Vector[parse_float($2) || 0.0, parse_float($4) || 0.0]
+
+		# Section 4.4 - Image Parameters
+		when 'IJ'	# Deprecated
+		when 'IP'	# Deprecated
+		    /^IP(POS|NEG)/ =~ s
+		    current_layer.polarity = ('NEG' == $1) ? :negative : :positive
+		when 'IR'	# Deprecated
+		    /^IR(0|90|180|270)/ =~ s
+		    @rotation = $1.to_f.degrees
+
+		# Section 4.5 - Layer Specific Parameters
+		when 'KO'	# Deprecated
+		    /^KO(C|D)?(X([\d.+-]+)Y([\d.+-]+)I([\d.+-]+)J([\d.+-]+))?/ =~ s
+		    polarity, x, y, i, j = $1, $3, $4, $5, $6
+		    raise ParseError, "KO not supported"
+		when 'LN'
+		    /^LN([[:print:]]+)\*/ =~ s
+		    new_layer.name = $1
+		when 'LP'
+		    /^LP(C|D)/ =~ s
+		    @new_layer_polarity = ('C' == $1) ? :clear : :dark
+		    current_layer.polarity = @new_layer_polarity
+		when 'SR'
+		    /^SR(X(\d+))?(Y(\d+))?(I([\d.+-]+))?(J([\d.+-]+))?/ =~ s
+		    x, y, i, j = $2, $4, parse_float($6), parse_float($8)
+		    layer = new_layer
+		    layer.step = Vector[i || 0, j || 0]
+		    layer.repeat = Vector[x || 1, y || 1]
+		else
+		    raise ParseError, "Unrecognized Parameter Type: '#{directive}'"
+	    end
+	end
+    end
+end