Class: Gerber::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/gerber/parser.rb

Overview

Read and parse Gerber files (RS-274X)

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Parser

Returns a new instance of Parser.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/gerber/parser.rb', line 20

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

Instance Attribute Details

#absolute ⇒ Object

Returns the value of attribute absolute.



14
15
16
 
# File 'lib/gerber/parser.rb', line 14

def absolute
  @absolute
end

#apertures ⇒ Object (readonly)

Returns the value of attribute apertures.



16
17
18
 
# File 'lib/gerber/parser.rb', line 16

def apertures
  @apertures
end

#decimal_places ⇒ Object

Returns the value of attribute decimal_places.



13
14
15
 
# File 'lib/gerber/parser.rb', line 13

def decimal_places
  @decimal_places
end

#eof ⇒ Object (readonly)

Returns the value of attribute eof.



17
18
19
 
# File 'lib/gerber/parser.rb', line 17

def eof
  @eof
end

#integer_places ⇒ Object

Returns the value of attribute integer_places.



13
14
15
 
# File 'lib/gerber/parser.rb', line 13

def integer_places
  @integer_places
end

#layers ⇒ Object (readonly)

Returns the value of attribute layers.



16
17
18
 
# File 'lib/gerber/parser.rb', line 16

def layers
  @layers
end

#total_places ⇒ Object (readonly)

Returns the value of attribute total_places.



18
19
20
 
# File 'lib/gerber/parser.rb', line 18

def total_places
  @total_places
end

#zero_omission ⇒ Object

Returns the value of attribute zero_omission.



14
15
16
 
# File 'lib/gerber/parser.rb', line 14

def zero_omission
  @zero_omission
end

Instance Method Details

#coordinate_format=(*args) ⇒ Object

Set the format used for coordinates

Parameters:

  • integer_places (Number) —

    The number of digits to the left of the decimal point

  • decimal_places (Number) —

    The number of digits to the right of the decimal point



48
49
50
51
 
# File 'lib/gerber/parser.rb', line 48

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

#new_layer ⇒ Object

Create and return a new Layer::Parser



60
61
62
63
64
 
# File 'lib/gerber/parser.rb', line 60

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

#parse(input) ⇒ Object

Parse the given IO stream

Parameters:

  • input (IO) —

    An IO-like object to parse



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/gerber/parser.rb', line 80

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

#parse_coordinate(s) ⇒ Float

Convert a string into a Float using the current coordinate formating setting

Parameters:

  • s (String) —

    The string to convert

Returns:

  • (Float) —

    The resulting Float, or nil



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/gerber/parser.rb', line 126

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

#parse_float(s) ⇒ Float

Convert a string into a Float and apply the appropriate Units

Parameters:

  • s (String) —

    The string to convert

Returns:

  • (Float) —

    The resulting Float with units, or nil



146
147
148
 
# File 'lib/gerber/parser.rb', line 146

def parse_float(s)
    apply_units(s.to_f)
end

#parse_parameter(s) ⇒ Object

Parse a set of parameter blocks



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/gerber/parser.rb', line 151

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

#set_inches ⇒ Object

Assume that all dimensions are in inches



67
68
69
70
 
# File 'lib/gerber/parser.rb', line 67

def set_inches
    @units = 'inch'
    current_layer.set_inches
end

#set_millimeters ⇒ Object

Assume that all dimensions are in millimeters



73
74
75
76
 
# File 'lib/gerber/parser.rb', line 73

def set_millimeters
    @units = 'millimeters'
    current_layer.set_millimeters
end