rubyscad 1.0.0

data/README.md

@@ -0,0 +1,425 @@
+RubyScad
+========
+
+Ruby module to easily generate openscad scripts
+
+General Usage
+
+Requirements: Ruby 1.9.3
+
+RubyScad is a ruby mixin module which provides functions which allow easy output of openscad scripts .  To use simply "include" or "extend" the module into any class or module:
+
+
+  --------------------------------test.rb--------------------------------------
+
+  load "RubyScad.rb" #or use require but it must be in ruby's system path
+
+  
+
+  module Test
+
+    extend RubyScad #extend makes all function available at the class level
+
+    
+
+    def self.cone(base=5, height=10)
+
+      cylinder(r1: base, r2: 0, h:height)
+
+    end
+
+    
+
+    cone(2, 4)
+
+  end
+
+  ----------------------------------------------------------------------------
+
+  from command line: 
+
+  print to standard output: ruby test.rb
+
+  generate file: ruby test.rb "test.scad"
+
+  --------------------------------test2.rb------------------------------------
+
+  load "RubyScad.rb" #or use require but it must be in ruby's system path
+
+  
+
+  class Test2
+
+    include RubyScad #includ makes function available within the class/module
+
+    
+
+    def initialize(args={})
+
+      @radius = args.fetch(:radius, 3)
+
+    end
+
+    
+
+    def render()
+
+      sphere(r:@radius)
+
+    end
+
+  end
+
+  
+
+  Test2.new.render
+
+  ----------------------------------------------------------------------------
+
+  from command line: 
+
+  print to standard output: ruby test2.rb
+
+  generate file: ruby test2.rb "test2.scad"
+
+  
+
+
+
+General Considerations:
+
+    -All arguments passed to rubyscad functions are passed as named hash values matching the openscad spec, exceptions are for functions fa, fs, fn, echo, include, and use (see below).
+
+      openscad: cube(6)
+
+      rubyscad: cube(size: 6)
+
+    -Any arguments may be passed to functions (with the exception of the ones noted above) but openscad may or may not use these values
+
+      -cube(openscadwontusethis: 5) will produce the following openscad
+
+         -cube(openscadwontusethis = 5);
+
+        nothing bad will happen here, the value will just have no effect
+
+    -$fn, $fs, $fa variables are passed without the '$'
+
+      openscad: sphere(4, $fn=12)
+
+      rubyscad: sphere(r: 4, fn: 12)
+
+    -Ruby's math functions use radians, openscad uses degrees, for ease I've added a 'radians' function to the numeric class so the following is possible
+
+      openscad: sin(15)
+
+      rubyscad: Math.sin(15.radians)
+
+    -All functions which take code blocks (union, difference, intersection, ...) can use the form "function() { code }" or "function()" with the following result
+
+      the code:
+
+        translate(x: 5)
+
+        cube(size: 7)
+
+      would produce:
+
+        translate([5,0,0])
+
+        cube(size = 7);
+
+      the code
+
+        translate(x: 5) {
+
+          cube(size: 7)
+
+        }
+
+      would produce:
+
+        translate([5,0,0]) {
+
+          cube(size = 7);
+
+        }
+
+        
+
+Openscad Functions:      
+
+----------------------------------------------------------------------------
+
+  openscad: $fa = 0.2;
+
+  rubyscad: fa 0.2
+
+----------------------------------------------------------------------------
+
+  openscad: $fs = 2;
+
+  rubyscad: fs 2
+
+----------------------------------------------------------------------------
+
+  openscad: $fn = 5;
+
+  rubyscad: fn 5
+
+----------------------------------------------------------------------------
+
+  openscad: include <file.scad>
+
+  rubyscad: include_scad "file.scad"
+
+----------------------------------------------------------------------------
+
+  openscad: use <file.scad>
+
+  rubyscad: use "file.scad"
+
+----------------------------------------------------------------------------
+
+  openscad: echo(1,2,3);
+
+  rubyscad: echo 1, 2, 3
+
+----------------------------------------------------------------------------
+
+  openscad: %
+
+  rubyscad: background
+
+----------------------------------------------------------------------------
+
+  openscad: #
+
+  rubyscad: debug
+
+----------------------------------------------------------------------------
+
+  openscad: !
+
+  rubyscad: root
+
+----------------------------------------------------------------------------
+
+  openscad: *
+
+  rubyscad: disable
+
+----------------------------------------------------------------------------
+
+  openscad: projection([args]) [{ code }]
+
+  rubyscad: projection([args]) [{ code }]
+
+----------------------------------------------------------------------------
+
+  openscad: linear_extrude([args]) [{ code }]
+
+  rubyscad: linear_extrude([args]) [{ code }]
+
+----------------------------------------------------------------------------
+
+  openscad: rotate_extrude([args]) [{ code }]
+
+  rubyscad: rotate_extrude([args]) [{ code }]
+
+----------------------------------------------------------------------------
+
+  openscad: import([args])
+
+  rubyscad: import([args])
+
+----------------------------------------------------------------------------
+
+  openscad: difference() { code }
+
+  rubyscad: difference() { code }
+
+----------------------------------------------------------------------------
+
+  openscad: union() { code }
+
+  rubyscad: union() { code }
+
+----------------------------------------------------------------------------
+
+  openscad: intersection() { code }
+
+  rubyscad: intersection() { code }
+
+----------------------------------------------------------------------------
+
+  openscad: render([args]) [{ code }]
+
+  rubyscad: render([args]) [{ code }]
+
+----------------------------------------------------------------------------
+
+  openscad: minkowski() { code }
+
+  rubyscad: minkowski() { code }
+
+----------------------------------------------------------------------------
+
+  openscad: hull() { code }
+
+  rubyscad: hull() { code }
+
+----------------------------------------------------------------------------
+
+  openscad: cube([args])
+
+  rubyscad: cube([args])
+
+----------------------------------------------------------------------------
+
+  openscad: sphere([args])
+
+  rubyscad: sphere([args])
+
+  In addition to the normal arguments d: can also be provided instead of r: to
+
+  specify the diameter instead of the radius
+
+----------------------------------------------------------------------------
+
+  openscad: polyhedron([args])
+
+  rubyscad: polyhedron([args])
+
+----------------------------------------------------------------------------
+
+  openscad: square([args])
+
+  rubyscad: square([args])
+
+----------------------------------------------------------------------------
+
+  openscad: circle([args])
+
+  rubyscad: circle([args])
+
+  In addition to the normal arguments d: can also be provided instead of r: to
+
+  specify the diameter instead of the radius
+
+----------------------------------------------------------------------------
+
+  openscad: polygon([args])
+
+  rubyscad: polygon([args])
+
+----------------------------------------------------------------------------
+
+  openscad: surface([args])
+
+  rubyscad: surface([args])
+
+----------------------------------------------------------------------------
+
+  openscad: cylinder([args])
+
+  rubyscad: cylinder([args])
+
+----------------------------------------------------------------------------
+
+  openscad: rotate([args]) [{ code }]
+
+  rubyscad: rotate([args]) [{ code }]
+
+  In addition to the normal arguments x:, y:, and z: can be used instead of 
+
+  the normal vector input
+
+----------------------------------------------------------------------------
+
+  openscad: translate([args]) [{ code }]
+
+  rubyscad: translate([args]) [{ code }]
+
+  In addition to the normal arguments x:, y:, and z: can be used instead of 
+
+  the normal vector input
+
+----------------------------------------------------------------------------
+
+  openscad: scale([args]) [{ code }]
+
+  rubyscad: scale([args]) [{ code }]
+
+  In addition to the normal arguments x:, y:, and z: can be used instead of 
+
+  the normal vector input
+
+----------------------------------------------------------------------------
+
+  openscad: mirror([args]) [{ code }]
+
+  rubyscad: mirror([args]) [{ code }]
+
+  In addition to the normal arguments x:, y:, and z: can be used instead of 
+
+  the normal vector input
+
+----------------------------------------------------------------------------
+
+  openscad: multmatrix([args]) [{ code }]
+
+  rubyscad: multmatrix([args]) [{ code }]
+
+----------------------------------------------------------------------------
+
+  openscad: color([args]) [{ code }]
+
+  rubyscad: color([args]) [{ code }]
+
+  Instead of color: being a vector, r:, g:, b:, and a: can be provided
+
+  
+
+RubyScad Functions:
+
+----------------------------------------------------------------------------
+
+  format_command(cmd_str, args={}, &block)
+
+    an easy way to implement new openscad commands.
+
+    cmd_str should be in the form "func_name(%<args>);"
+
+    all arguments passed from "args" will be inserted into the <args> string modifier, if
+
+    a block is passed it will output between { }
+
+----------------------------------------------------------------------------
+
+  new_line
+
+    outputs a new line
+
+----------------------------------------------------------------------------
+
+  start_block
+
+    outputs a { at the correct tab level
+
+----------------------------------------------------------------------------
+
+  end_block
+
+    outputs a } at the correct tab level
+
+----------------------------------------------------------------------------
+
+  end_all_blocks
+
+    outputs a } for every open block
+
+----------------------------------------------------------------------------
+
+  format_output
+
+    outputs a string at the correct tab level

data/lib/RubyScad.rb

@@ -0,0 +1,349 @@
+require 'matrix'
+
+class Numeric
+  def radians
+    self * Math::PI / 180
+  end
+end
+
+class Float
+  FP_P = 3
+  def to_s
+    "%.#{FP_P}f" % self.round(FP_P)
+  end
+end
+
+module RubyScad
+  START_BLOCK = "{"
+  END_BLOCK = "}"
+  TAB_SIZE = 3
+  PAD = 0.01
+
+  CUBE_STR = "cube(%<args>s);"
+  SPHERE_STR = "sphere(%<args>s);"
+  CYLINDER_STR = "cylinder(%<args>s);"
+  POLYHEDRON_STR = "polyhedron(%<args>s);"
+  SQUARE_STR = "square(%<args>s);"
+  CIRCLE_STR = "circle(%<args>s);"
+  POLYGON_STR = "polygon(%<args>s);"
+  TRANSLATE_STR = "translate(%<args>s)"
+  ROTATE_STR = "rotate(%<args>s)"
+  SCALE_STR = "scale(%<args>s)"
+  MIRROR_STR = "mirror(%<args>s)"
+  MULTMATRIX_STR = "multmatrix(%<args>s)"
+  COLOR_STR = "color(%<args>s)"
+  UNION_STR = "union(%<args>s)"
+  DIFFERENCE_STR = "difference(%<args>s)"
+  INTERSECTION_STR = "intersection(%<args>s)"
+  RENDER_STR = "render(%<args>s)"
+  MINKOWSKI_STR = "minkowski(%<args>s)"
+  HULL_STR = "hull(%<args>s)"
+  BACKGROUND_STR = '%'
+  DEBUG_STR = '#'
+  ROOT_STR = '!'
+  DISABLE_STR = '*'
+  IMPORT_STR = "import(%<args>s);"
+  SURFACE_STR = "surface(%<args>s);"
+  LINEAR_EXTRUDE_STR = "linear_extrude(%<args>s)"
+  ROTATE_EXTRUDE_STR = "rotate_extrude(%<args>s)"
+  PROJECTION_STR = "projection(%<args>s)"
+
+  INCLUDE_STR = "include <%<file>s>"
+  USE_STR = "use <%<file>s>"
+  ECHO_STR = "echo(%<string>s);"
+  FA_STR = "$fa = %<value>s;"
+  FS_STR = "$fs = %<value>s;"
+  FN_STR = "$fn = %<value>s;"
+
+  def fa(value)
+    format_output FA_STR % {value: value}
+  end
+
+  def fs(value)
+    format_output FS_STR % {value: value}
+  end
+
+  def fn(value)
+    format_output FN_STR % {value: value}
+  end
+
+  def include_scad(file)
+    format_output INCLUDE_STR % {file: file}
+  end
+
+  def use(file)
+    format_output USE_STR % {file: file}
+  end
+
+  def echo(*args)
+    format_output ECHO_STR % {string: args.join(', ')}
+  end
+
+  def projection(args={}, &block)
+    format_command PROJECTION_STR, args, &block
+  end
+  
+  def linear_extrude(args={}, &block)
+    str_end = args.include?(:file) ? ";" : ""
+    format_command LINEAR_EXTRUDE_STR.concat(str_end), args, &block
+  end
+
+  def rotate_extrude(args={}, &block)
+    str_end = args.include?(:file) ? ";" : ""
+    format_command ROTATE_EXTRUDE_STR.concat(str_end), args, &block
+  end
+
+  def import(args={})
+    format_command IMPORT_STR, args
+  end
+
+  def difference(&block)
+    format_command DIFFERENCE_STR, &block
+  end
+
+  def union(&block)
+    format_command UNION_STR, &block
+  end
+
+  def intersection(&block)
+    format_command INTERSECTION_STR, &block
+  end
+
+  def render(args={}, &block)
+    format_command RENDER_STR, args, &block 
+  end
+
+  def minkowski(&block)
+    format_command MINKOWSKI_STR, &block
+  end
+
+  def hull(&block)
+    format_command HULL_STR, &block
+  end
+
+  def background()
+    format_output BACKGROUND_STR
+    yield if block_given?
+  end
+
+  def debug()
+    format_output DEBUG_STR
+    yield if block_given?
+  end
+
+  def root()
+    format_output ROOT_STR
+    yield if block_given?
+  end
+
+  def disable()
+    format_output DISABLE_STR
+    yield if block_given?
+  end
+
+  def cube(args={})
+    format_command CUBE_STR, args
+  end
+
+  def sphere(args={})
+    if args.include?(:d)
+      args[:r] = args[:d]/2.0
+      args.delete(:d)
+    end
+    format_command SPHERE_STR, args
+  end
+
+  def polyhedron(args={})
+    format_command POLYHEDRON_STR, args
+  end
+
+  def square(args={})
+    format_command SQUARE_STR, args
+  end
+
+  def circle(args={})
+    if args.include?(:d)
+      args[:r] = args[:d]/2.0
+      args.delete(:d)
+    end
+    format_command CIRCLE_STR, args
+  end
+
+  def polygon(args={})
+    format_command POLYGON_STR, args
+  end
+
+  def surface(args={})
+    format_command SURFACE_STR, args
+  end
+
+  def cylinder(args={})
+    format_command CYLINDER_STR, args
+  end
+
+  def rotate(args={}, &block)
+    vector_input(args, :a)
+    format_command ROTATE_STR, args, &block
+  end
+
+  def translate(args={}, &block)
+    vector_input(args, :v)
+    format_command TRANSLATE_STR, args, &block
+  end
+
+  def scale(args={}, &block)
+    vector_input(args, :v)
+    format_command SCALE_STR, args, &block
+  end
+
+  def mirror(args={}, &block)
+    vector_input(args, :v)
+    format_command MIRROR_STR, args, &block
+  end
+
+  def multmatrix(args={}, &block)
+    format_command MULTMATRIX_STR, args, &block
+  end
+
+  def color(args={}, &block)
+    args[:color] = [args.fetch(:r, 0), args.fetch(:g, 0), args.fetch(:b, 0), args.fetch(:a, 1)] unless args.include?(:color)
+    delete_from(args, :r, :g, :b, :a)
+    format_command COLOR_STR, args, &block
+  end
+
+  def format_command(cmd_str, args={}, &block)
+    arg_str = args.collect { |k, v| "#{format_key(k)} = #{format_value(v)}" }.join(', ')
+    format_block cmd_str % {args: arg_str}, &block
+  end
+  
+  def format_key(key)
+    key = key.to_s
+    key.prepend('$') if key.match("^f[asn]$")
+    key
+  end
+
+  def format_value(var)
+    if var.is_a?(Vector) or var.is_a?(Matrix)
+      return var.to_a.to_s
+    elsif var.is_a? String
+      return '"' + var + '"'
+    else
+      return var.to_s
+    end
+  end
+
+  def delete_from(hash, *keys)
+    keys.each { |k| hash.delete(k) }
+  end
+
+  def vector_input(args, element)
+    unless args.include?(element)
+      args[element] = [args.fetch(:x, 0), args.fetch(:y, 0)]
+      args[element].push(args[:z]) if args.include?(:z)
+      delete_from(args, :x, :y, :z)
+    end
+  end
+
+  def format_block(output_str)
+    format_output output_str.concat(' ')
+    if block_given?
+      start_block
+      yield
+      end_block
+    else
+      new_line unless output_str.include?(';')
+    end
+  end
+
+  def new_line
+    format_output "\n"
+  end
+
+  def start_block()
+    format_output START_BLOCK
+  end
+
+  def end_block()
+    format_output END_BLOCK
+  end
+
+  def end_all_blocks()
+    end_block while @@tab_level > 0
+  end
+
+  def space_string(str, tab_level)
+    ((' '*TAB_SIZE)*tab_level) + str
+  end
+
+  def raw_output(str)
+    if @@output_file
+      File.open(@@output_file, 'a') { |f| f.print(str) } 
+    else
+      print str
+    end
+  end
+
+  def format_output(str)
+    @@prev_output ||= ""
+    @@tab_level ||= 0
+    str.lines do |l|
+      l.concat("\n") if l.match('[;\}\{>]')
+      @@tab_level-=1 if(l.include?('}')) && @@tab_level > 0
+      l = space_string(l, @@tab_level) if @@prev_output.include?("\n") 
+      raw_output(l)
+      @@tab_level+=1 if(l.include?('{'))
+      @@prev_output = l
+    end
+  end
+
+  def self.start_output
+    @@output_file = nil
+    if ARGV[0] && ARGV[0].include?(".scad")
+      @@output_file = ARGV[0]
+      ARGV.shift
+    end
+    if @@output_file
+      File.open(@@output_file, 'w') do |f|
+        f.puts "//created with rubyscad #{VERSION}\n\n"
+      end
+    end
+  end
+
+  def self.extended(mod)
+    start_output
+    mod.class_variable_set(:@@fa, 30)
+  end
+
+  def self.included(mod)
+    start_output
+  end
+
+  start_output if __FILE__== $0  
+
+  def lookup(x, points)
+    xmin, xmax = [0.0, 0.0]
+    points.keys.sort.reverse_each do |k|
+      if k <= x
+        xmin = k
+        break
+      end
+    end
+    points.keys.sort.each do |k|
+      if k >= x
+        xmax = k
+        break
+      end
+    end
+    return points[xmax] if x == xmax
+    return points[xmin] if x == xmin
+    return points[xmin] + (((x - xmin) * (points[xmax] - points[xmin])) / (xmax - xmin))
+  end
+
+  def dxf_cross(args={})
+    return 0.0
+  end
+
+  def dxf_dim(args={})
+    return 0.0
+  end
+end

data/lib/rubyscad/version.rb

@@ -0,0 +1,3 @@
+module RubyScad
+  VERSION = "1.0.0"
+end

data/lib/rubyscad.rb

@@ -0,0 +1,8 @@
+# I put this file here to both make bundler happy with a gem named 'rubyscad'
+# (all lowercase) and to provide a place to start breaking the project into
+# smaller components.
+#
+# Hope that wasn't too presumptious :-\
+require 'RubyScad'
+
+require 'rubyscad/version'

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: rubyscad
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Curtis Bissonnette
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-20 00:00:00.000000000 Z
+dependencies: []
+description: Ruby module to easily generate openscad scripts
+email:
+- cjbissonnette
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rubyscad/version.rb
+- lib/rubyscad.rb
+- lib/RubyScad.rb
+- README.md
+homepage: http://github.com/cjbissonnette
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby module to easily generate openscad scripts
+test_files: []