Class: JennCad::Exporters::OpenScad

Inherits:
Object
  • Object
show all
Includes:
ActiveSupport::Inflector
Defined in:
lib/jenncad/exporters/openscad.rb

Instance Method Summary collapse

Constructor Details

#initialize(part) ⇒ OpenScad

Returns a new instance of OpenScad.



124
125
126
127
128
129
 
# File 'lib/jenncad/exporters/openscad.rb', line 124

def initialize(part)
  @imports = []
  @modules = {}
  @global_fn = 64
  @object_tree = OpenScadObject.new(:head, nil, parse(part))
end

Instance Method Details

#apply_color(part, &block) ⇒ Object 



237
238
239
240
 
# File 'lib/jenncad/exporters/openscad.rb', line 237

def apply_color(part, &block)
  return block.yield if part.nil? or part.color_or_fallback.nil?
  OpenScadObject.new("color", part.color_or_fallback, block.yield)
end

#bool(type, part) ⇒ Object 



211
212
213
 
# File 'lib/jenncad/exporters/openscad.rb', line 211

def bool(type, part)
  new_obj(part, type, nil, parse(part.parts))
end

#collect_params(part) ⇒ Object 



219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/jenncad/exporters/openscad.rb', line 219

def collect_params(part)
  if part.respond_to? :openscad_params
    return part.openscad_params
  end
  res = {}
  [:d, :h, :d1, :d2, :size, :fn, :points, :paths, :faces, :convexity, :file].each do |var|
    if part.respond_to? var
      res[var] = part.send var
    end
  end
  case res[:fn]
  when @global_fn
    res[:fn] = nil
  else
  end
  res
end

#handle_aggregation(part, tabindex = 0) ⇒ Object 



261
262
263
264
265
266
267
 
# File 'lib/jenncad/exporters/openscad.rb', line 261

def handle_aggregation(part, tabindex=0)
  register_module(part) unless @modules[part.name]
  $log.debug "aggregation #{part.name} transformations: #{part.transformations.inspect}" if part && part.option(:debug)
  transform(part.clone) do
    new_obj(part, part.name, nil)
  end
end

#handle_import(part) ⇒ Object 



274
275
276
277
 
# File 'lib/jenncad/exporters/openscad.rb', line 274

def handle_import(part)
  @imports << part.import
  new_obj(part, part.name, part.args)
end

#new_obj(part, cmd, args = nil, children = []) ⇒ Object 



202
203
204
205
206
207
208
209
 
# File 'lib/jenncad/exporters/openscad.rb', line 202

def new_obj(part, cmd, args=nil, children=[])
  transform(part) do
    apply_color(part) do
      modifier = part.openscad_modifier || nil
      OpenScadObject.new(cmd, args, children, modifier)
    end
  end
end

#parse(part) ⇒ Object 



144
145
146
147
148
149
150
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
 
# File 'lib/jenncad/exporters/openscad.rb', line 144

def parse(part)
  if part.respond_to? :to_openscad
    part = part.to_openscad
  end

  if part.respond_to? :analyze_z_fighting
    part = part.analyze_z_fighting
  end

  case part
  when Array
    part.map{ |p| parse(p) }
  when JennCad::OpenScadImport
    handle_import(part)
  when JennCad::Aggregation
    handle_aggregation(part)
  when JennCad::UnionObject
    bool('union', part)
  when JennCad::SubtractObject
    bool('difference', part)
  when JennCad::IntersectionObject
    bool('intersection', part)
  when JennCad::HullObject
    bool('hull', part)
  when JennCad::Primitives::Cylinder
    prim('cylinder', part)
  when JennCad::Primitives::Sphere
    prim('sphere', part)
  when JennCad::Primitives::Cube
    prim('cube', part)
   when JennCad::Primitives::Circle
    prim('circle', part)
  when JennCad::Primitives::Square
    prim('square', part)
  when JennCad::Primitives::Text
    prim('text', part)
  when JennCad::Primitives::LinearExtrude
    new_obj(part, :linear_extrude, part.openscad_params, parse(part.parts))
  when JennCad::Primitives::RotateExtrude
    new_obj(part, :rotate_extrude, part.openscad_params, parse(part.parts))
  when JennCad::Primitives::Projection
    new_obj(part, :projection, collect_params(part), parse(part.parts))
  when JennCad::Primitives::Polygon
    new_obj(part, :polygon, collect_params(part))
  when JennCad::Primitives::Polyhedron
    new_obj(part, :polyhedron, collect_params(part))
  when JennCad::StlImport
    new_obj(part, :import, collect_params(part))
  when JennCad::Part
    parse(part.part)
  when nil
    new_obj(part, nil)
  else
    puts "unknown part #{part.class}"
    OpenScadObject.new(nil,nil)
  end
end

#prim(type, part) ⇒ Object 



215
216
217
 
# File 'lib/jenncad/exporters/openscad.rb', line 215

def prim(type, part)
  new_obj(part, type, collect_params(part))
end

#register_module(part) ⇒ Object

accept aggregation



270
271
272
 
# File 'lib/jenncad/exporters/openscad.rb', line 270

def register_module(part)
  @modules[part.name] = OpenScadObject.new(:module, part.name, parse(part.part))
end

#save(file) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/jenncad/exporters/openscad.rb', line 131

def save(file)
  File.open(file,"w") do |f|
    @imports.uniq.each do |val|
      f.puts "use <#{val}.scad>\n"
    end

    @modules.each do |key, val|
      f.puts val.to_s
    end
    f.puts @object_tree.to_s
  end
end

#transform(part, &block) ⇒ Object 



242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/jenncad/exporters/openscad.rb', line 242

def transform(part, &block)
  return block.yield if part.transformations.nil?

  case t = part.transformations.pop
  when nil, []
    block.yield
  when JennCad::Move
    OpenScadObject.new(:translate, t.coordinates, transform(part, &block))
  when JennCad::Rotate, JennCad::Mirror
    OpenScadObject.new(demodulize(t.class).downcase, t.coordinates, transform(part, &block))
  when JennCad::Scale
    OpenScadObject.new(:scale, t.scale, transform(part, &block))
  when JennCad::Multmatrix
    OpenScadObject.new(:multmatrix, t.m, transform(part, &block))
  else
    puts "unknown transformation #{t}"
  end
end