rcad 0.0.1

data/ext/_rcad/extconf.rb

@@ -0,0 +1,22 @@
+require 'mkmf-rice'
+
+OCE_INCLUDE_DIR = '/usr/local/include/oce'
+OCE_LIB_DIR = '/usr/local/lib'
+
+dir_config('TKG3d', OCE_INCLUDE_DIR, OCE_LIB_DIR)
+dir_config('TKBRep', OCE_INCLUDE_DIR, OCE_LIB_DIR)
+dir_config('TKPrim', OCE_INCLUDE_DIR, OCE_LIB_DIR)
+dir_config('TKOffset', OCE_INCLUDE_DIR, OCE_LIB_DIR)
+dir_config('TKBO', OCE_INCLUDE_DIR, OCE_LIB_DIR)
+dir_config('TKSTL', OCE_INCLUDE_DIR, OCE_LIB_DIR)
+dir_config('qhull', '/usr/include/qhull', '/usr/lib')
+
+have_library('TKG3d') or raise
+have_library('TKBRep') or raise
+have_library('TKPrim') or raise
+have_library('TKOffset') or raise
+have_library('TKBO') or raise
+have_library('TKSTL') or raise
+have_library('qhull') or raise
+
+create_makefile('rcad/_rcad')

data/lib/rcad.rb

@@ -0,0 +1,384 @@
+require 'rcad/version'
+require 'rcad/_rcad'
+
+
+class Numeric
+  def mm
+    self
+  end
+
+  def cm
+    self * 10.0
+  end
+
+  def um
+    self / 1000.0
+  end
+
+  def in
+    self * 25.4
+  end
+
+  def deg_to_rad
+    self * Math::PI / 180
+  end
+
+  def rad_to_deg
+    self * 180 / Math::PI
+  end
+end
+
+
+def to_polar(r, a)
+  return [r * Math::cos(a), r * Math::sin(a)]
+end
+
+
+TOLERANCE = 50.um
+
+
+class Shape
+  # if @shape isn't defined in a Shape's initialize() method, then render()
+  # should be overridden to create and return it on-the-fly.
+  def render
+    @shape
+  end
+
+  def +(right)
+    Union.new(self, right)
+  end
+
+  def -(right)
+    Difference.new(self, right)
+  end
+
+  def *(right)
+    Intersection.new(self, right)
+  end
+
+  def ~@
+    if $shape_mode == :hull
+      $shape << self
+    else
+      $shape = ($shape == nil) ? self : $shape.send($shape_mode, self)
+    end
+
+    self
+  end
+
+  def move_x(delta)
+    move(delta, 0, 0)
+  end
+
+  def move_y(delta)
+    move(0, delta, 0)
+  end
+
+  def move_z(delta)
+    move(0, 0, delta)
+  end
+
+  def rot_x(angle)
+    rotate(angle, [1, 0, 0])
+  end
+
+  def rot_y(angle)
+    rotate(angle, [0, 1, 0])
+  end
+
+  def rot_z(angle)
+    rotate(angle, [0, 0, 1])
+  end
+
+  def scale_x(factor)
+    scale(factor, 1, 1)
+  end
+
+  def scale_y(factor)
+    scale(1, factor, 1)
+  end
+
+  def scale_z(factor)
+    scale(1, 1, factor)
+  end
+
+  def extrude(height, twist=0)
+    LinearExtrusion.new(self, height, twist)
+  end
+
+  def revolve(angle=360.deg_to_rad)
+    Revolution.new(self, angle)
+  end
+
+  def bbox
+    # TODO
+  end
+
+  def min_x
+    bbox[0].x
+  end
+
+  def min_y
+    bbox[0].y
+  end
+
+  def min_z
+    bbox[0].z
+  end
+
+  def max_x
+    bbox[1].x
+  end
+
+  def max_y
+    bbox[1].y
+  end
+
+  def max_z
+    bbox[1].z
+  end
+
+  def x_size
+    max_x - min_x
+  end
+
+  def y_size
+    max_y - min_y
+  end
+
+  def z_size
+    max_z - min_z
+  end
+end
+
+$shape_stack = []
+$shape = nil
+$shape_mode = :+
+
+def _shape_mode_block(mode, &block)
+  $shape_stack.push([$shape, $shape_mode])
+  $shape = nil
+  $shape_mode = mode
+
+  block.call
+  res = $shape
+
+  $shape, $shape_mode = $shape_stack.pop
+  res
+end
+
+def add(&block)
+  _shape_mode_block(:+, &block)
+end
+
+def sub(&block)
+  _shape_mode_block(:-, &block)
+end
+
+def mul(&block)
+  _shape_mode_block(:*, &block)
+end
+
+def hull(&block)
+  $shape_stack.push([$shape, $shape_mode])
+  $shape = []
+  $shape_mode = :hull
+
+  block.call
+  res = _hull($shape)
+
+  $shape, $shape_mode = $shape_stack.pop
+  res
+end
+
+def write_stl(*args)
+  $shape != nil or raise
+  $shape.write_stl(*args)
+end
+
+def clear_shape
+  $shape = nil
+end
+
+at_exit do
+  if $shape && ($! == nil)
+    output_file = File.basename($0, ".*") + ".stl"
+    printf("Rendering '%s'\n", output_file)
+    write_stl(output_file)
+  end
+end
+
+
+class Polygon
+  attr_reader :points, :paths
+
+  def initialize(points, paths=nil)
+    @points = points
+    @paths = paths || [(0...points.size).to_a]
+  end
+end
+
+
+class RegularPolygon < Polygon
+  attr_reader :sides, :radius
+
+  def initialize(sides, radius)
+    @sides = sides
+    @radius = radius
+
+    angles = (1..sides).map { |i| i * 2 * Math::PI / sides }
+    points = angles.map { |a| to_polar(radius, a) }
+    super(points)
+  end
+end
+
+
+class Square < Polygon
+  attr_reader :size
+
+  def initialize(size)
+    @size = size
+
+    super([[0,0], [size,0], [size,size], [0,size]])
+  end
+end
+
+
+class Circle < Shape
+  attr_accessor :dia
+
+  def initialize(dia)
+    @dia = dia
+  end
+end
+
+
+class Text < Shape
+    # TODO
+end
+
+
+class Box < Shape
+  attr_accessor :xsize, :ysize, :zsize
+
+  def initialize(xsize, ysize, zsize)
+    @xsize = xsize
+    @ysize = ysize
+    @zsize = zsize
+  end
+end
+
+class Cube < Box
+  def initialize(size)
+    super(size, size, size)
+  end
+end
+
+
+class Cylinder < Shape
+  attr_accessor :height, :dia
+
+  def initialize(height, dia)
+    @height = height
+    @dia = dia
+  end
+
+  def radius
+    dia / 2.0
+  end
+end
+
+
+class Sphere < Shape
+  attr_accessor :dia
+
+  def initialize(dia)
+    @dia = dia
+  end
+
+  def radius
+    dia / 2.0
+  end
+end
+
+
+class Polyhedron < Shape
+  attr_accessor :points, :faces
+
+  def initialize(points, faces)
+    @points = points
+    @faces = faces
+  end
+end
+
+
+class Torus < Shape
+  attr_accessor :inner_dia, :outer_dia, :angle
+
+  def initialize(inner_dia, outer_dia, angle=nil)
+    @inner_dia = inner_dia
+    @outer_dia = outer_dia
+    @angle = angle
+  end
+
+  def inner_radius
+    inner_dia / 2.0
+  end
+
+  def outer_radius
+    outer_dia / 2.0
+  end
+end
+
+
+class LinearExtrusion < Shape
+  attr_reader :profile, :height
+
+  def initialize(profile, height, twist=0)
+    @profile = profile
+    @height = height
+    @twist = twist
+  end
+end
+
+
+class Revolution < Shape
+  attr_reader :profile, :angle
+
+  def initialize(profile, angle=nil)
+    @profile = profile
+    @angle = angle
+  end
+end
+
+
+class RegularPrism < LinearExtrusion
+  attr_reader :sides, :radius
+
+  def initialize(sides, radius, height)
+    @sides = sides
+    @radius = radius
+
+    poly = RegularPolygon.new(sides, radius)
+    super(poly, height)
+  end
+end
+
+
+def make_maker(name, klass)
+  Object.send(:define_method, name, &klass.method(:new))
+end
+
+make_maker :polygon, Polygon
+make_maker :reg_poly, RegularPolygon
+make_maker :square, Square
+make_maker :circle, Circle
+make_maker :text, Text
+
+make_maker :box, Box
+make_maker :cube, Cube
+make_maker :cylinder, Cylinder
+make_maker :sphere, Sphere
+make_maker :polyhedron, Polyhedron
+make_maker :torus, Torus
+make_maker :reg_prism, RegularPrism

data/lib/rcad/gears.rb

@@ -0,0 +1,144 @@
+# calculations based on:
+# * http://makezine.com/2010/06/28/make-your-own-gears/
+#   based in turn on http://www.bostongear.com/pdf/gear_theory.pdf
+#   (can be found in Wayback Machine)
+# * http://en.wikipedia.org/wiki/Gear
+# * http://www.metrication.com/engineering/gears.html
+
+
+require 'rcad'
+
+
+class GearProfile < Shape
+  attr_reader :pitch_dia, :module_, :p_angle
+
+  # pitch_dia - effective diameter of gear
+  #   (not the same as outer diameter)
+  # module_ - ratio of pitch diameter to number of teeth (basically the
+  #   arc length of the tooth spacing)
+  # p_angle - pressure angle.
+  #   it seems 20 deg angle is better for torque, but
+  #   14.5 deg angle is better for backlash.
+  def initialize(pitch_dia, module_=4, p_angle=20)
+    # converting everything to floats ensures that floating point
+    # division will be performed later
+    @pitch_dia = pitch_dia.to_f
+    @module_ = module_.to_f
+    @p_angle = p_angle.to_f
+
+    if @pitch_dia % @module_ != 0
+      raise ArgumentError, "non-integer number of teeth!"
+    end
+  end
+
+  def num_teeth
+    (pitch_dia / module_).to_int
+  end
+
+  def diametrical_pitch
+    1.0 / module_
+  end
+
+  def circular_pitch
+    Math::PI / diametrical_pitch
+  end
+
+  def addendum
+    1.0 / diametrical_pitch
+  end
+
+  def outer_dia
+    pitch_dia + 2.0 * addendum
+  end
+
+  def whole_depth
+    module_ < 1.25 ? (2.4 * module_) : (2.25 * module_)
+  end
+
+  def dedendum
+    whole_depth - addendum
+  end
+
+  def root_dia
+    pitch_dia - 2 * dedendum
+  end
+
+  # tooth thickness at pitch dia
+  def tooth_thickness
+    Math::PI / 2.0 / diametrical_pitch
+  end
+
+  def render
+    # tooth thickness at tooth tip (TODO: is this correct?)
+    tooth_tip_thickness = tooth_thickness - addendum * Math::sin(p_angle)
+
+    # half of thickness at root/center/tip in degrees
+    half_t_root_angle = Math::atan(tooth_thickness / 2 / (root_dia / 2))
+    half_t_angle = Math::atan(tooth_thickness / 2 / (pitch_dia / 2))
+    half_t_tip_angle = Math::atan(tooth_tip_thickness / 2 / (outer_dia / 2))
+
+    root_r = root_dia / 2
+    pitch_r = pitch_dia / 2
+    outer_r = outer_dia / 2
+
+    points = []
+    (1..num_teeth).each do |i|
+      angle = (2 * Math::PI / num_teeth) * i
+      points << to_polar(root_r, angle - half_t_root_angle)
+      points << to_polar(pitch_r, angle - half_t_angle)
+      points << to_polar(outer_r, angle - half_t_tip_angle)
+      points << to_polar(outer_r, angle + half_t_tip_angle)
+      points << to_polar(pitch_r, angle + half_t_angle)
+      points << to_polar(root_r, angle + half_t_root_angle)
+    end
+
+    polygon(points)
+  end
+end
+
+
+class SpurGear < Shape
+  attr_reader :height, :profile
+
+  def initialize(height, *args)
+    @height = height
+    @profile = GearProfile.new(*args)
+    @shape = profile.extrude(height)
+  end
+end
+
+
+class HelicalGear < Shape
+  attr_reader :height, :helix_angle, :profile
+
+  def initialize(pitch_dia, height, helix_angle=Math::PI / 3.0)
+    @height = height
+    @helix_angle = helix_angle
+    @profile = GearProfile.new(pitch_dia)
+
+    @shape = profile.extrude(height, twist)
+  end
+
+  def twist
+    twist_length = Math::tan(helix_angle) * height
+    pitch_circumference = Math::PI * profile.pitch_dia
+
+    twist_length * (2 * Math::PI / pitch_circumference)
+  end
+end
+
+
+class HerringboneGear < Shape
+  attr_reader :helical_gear
+
+  def initialize(pitch_dia, height, helix_angle=Math::PI / 3.0)
+    @helical_gear = HelicalGear.new(pitch_dia, height / 2.0, helix_angle)
+
+    @shape = add do
+        ~helical_gear
+        ~helical_gear
+          .scale_z(-1)
+          .move_z(height)
+      end
+  end
+end