rubyscad 1.0.4 → 1.0.5

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+Gemfile.lock
+doc/
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 cjbissonnette
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/BasicCube.rb

@@ -0,0 +1,50 @@
+require 'rubyscad'
+
+class BasicCube
+  include RubyScad
+
+  attr_accessor :size, :center
+
+  def initialize(args={})
+    @size = args.fetch(:size, [1,1,1])
+    @center = args.fetch(:center, true)
+  end
+
+  def x()
+    @size[0]
+  end
+
+  def x=(value)
+    @size[0] = value
+  end
+
+  def y()
+    @size[1]
+  end
+
+  def y=(value)
+    @size[1] = value
+  end
+
+  def z()
+    @size[2]
+  end
+
+  def z=(value)
+    @size[2] = value
+  end
+
+  def translate_centered(&block)
+    unless @center
+      translate(v:[x/2.0, y/2.0, z/2.0], &block)
+    else
+      yield
+    end
+  end
+
+  def render(args={})
+    translate_centered {
+      cube(size:@size, center: true)
+    }
+  end
+end

data/examples/ChamferCube.rb

@@ -0,0 +1,96 @@
+load 'BasicCube.rb'
+
+class ChamferCube < BasicCube
+
+  def initialize(args={})
+    super
+    @chamfer = [].fill(0, 0..11)
+  end
+
+  def chamfer_edge(edge, value)
+    @chamfer[edge] = value
+  end
+
+  def chamfer_edges(array)
+    array.each { |v| chamfer_edge(v[0], v[1]) }
+  end
+
+  def chamfer_side(side, value)
+    case side
+    when 0
+      chamfer_edge(0, value)
+      chamfer_edge(1, value)
+      chamfer_edge(2, value)
+      chamfer_edge(3, value)
+    when 1
+      chamfer_edge(0, value)
+      chamfer_edge(4, value)
+      chamfer_edge(5, value)
+      chamfer_edge(8, value)
+    when 2
+      chamfer_edge(5, value)
+      chamfer_edge(1, value)
+      chamfer_edge(6, value)
+      chamfer_edge(9, value)
+    when 3
+      chamfer_edge(2, value)
+      chamfer_edge(6, value)
+      chamfer_edge(7, value)
+      chamfer_edge(10, value)
+    when 4
+      chamfer_edge(3, value)
+      chamfer_edge(4, value)
+      chamfer_edge(11, value)
+      chamfer_edge(7, value)
+    when 5
+      chamfer_edge(8, value)
+      chamfer_edge(9, value)
+      chamfer_edge(10, value)
+      chamfer_edge(11, value)
+    end
+  end
+
+  def chamfer_sides(array)
+    array.each{ |v| chamfer_side(v[0], v[1]) }
+  end
+
+  def apply_chamfer(edge, value)
+      case edge
+      when 0
+        translate(y: -y/2.0, z: z/2.0) { rotate(x:45) { chamfer_cube([x+PAD, value, value]) } }
+      when 1
+        translate(x: x/2.0, y: -y/2.0) { rotate(z:45) { chamfer_cube([value, value, z+PAD]) } }
+      when 2
+        translate(y: -y/2.0, z: -z/2.0) { rotate(x:45) { chamfer_cube([x+PAD, value, value]) } }
+      when 3
+        translate(x: -x/2.0, y: -y/2.0) { rotate(z:45) { chamfer_cube([value, value, z+PAD]) } }
+      when 4
+        translate(x: -x/2.0, z: z/2.0) { rotate(y:45) { chamfer_cube([value, y+PAD, value]) } }
+      when 5
+        translate(x: x/2.0, z: z/2.0) { rotate(y:45) { chamfer_cube([value, y+PAD, value]) } }
+      when 6
+        translate(x: x/2.0, z: -z/2.0) { rotate(y:45) { chamfer_cube([value, y+PAD, value]) } }
+      when 7
+        translate(x: -x/2.0, z: -z/2.0) { rotate(y:45) { chamfer_cube([value, y+PAD, value]) } }
+      when 8
+        translate(y: y/2.0, z: z/2.0) { rotate(x:45) { chamfer_cube([x+PAD, value, value]) } }
+      when 9
+        translate(x: x/2.0, y: y/2.0) { rotate(z:45) { chamfer_cube([value, value, z+PAD]) } }
+      when 10
+        translate(y: y/2.0, z: -z/2.0) { rotate(x:45) { chamfer_cube([x+PAD, value, value]) } }
+      when 11
+        translate(x: -x/2.0, y: y/2.0) { rotate(z:45) { chamfer_cube([value, value, z+PAD]) } }
+      end
+  end
+
+  def chamfer_cube(size)
+    cube(size: size, center: true)
+  end
+
+  def render(args={})
+    difference {
+      super
+      @chamfer.each_with_index { |v, i| apply_chamfer(i, v) if v > 0 }
+    }
+  end
+end

data/examples/FilletCube.rb

@@ -0,0 +1,317 @@
+load "ChamferCube.rb"
+
+class FilletCube < ChamferCube
+  
+  attr_accessor :smooth
+
+  def initialize(args={})
+    super
+    @smooth = 30
+    @fillet = [].fill(0, 0..11)
+  end
+
+  def fillet_edge(edge, value)
+    @fillet[edge] = value
+  end
+  
+  def fillet_edges(array)
+    array.each { |v| fillet_edge(v[0], v[1]) }
+  end
+
+  def fillet_side(side, value)
+    case side
+    when 0
+      fillet_edge(0, value)
+      fillet_edge(1, value)
+      fillet_edge(2, value)
+      fillet_edge(3, value)
+    when 1
+      fillet_edge(0, value)
+      fillet_edge(4, value)
+      fillet_edge(5, value)
+      fillet_edge(8, value)
+    when 2
+      fillet_edge(5, value)
+      fillet_edge(1, value)
+      fillet_edge(6, value)
+      fillet_edge(9, value)
+    when 3
+      fillet_edge(2, value)
+      fillet_edge(6, value)
+      fillet_edge(7, value)
+      fillet_edge(10, value)
+    when 4
+      fillet_edge(3, value)
+      fillet_edge(4, value)
+      fillet_edge(11, value)
+      fillet_edge(7, value)
+    when 5
+      fillet_edge(8, value)
+      fillet_edge(9, value)
+      fillet_edge(10, value)
+      fillet_edge(11, value)
+    end
+  end
+
+  def fillet_sides(array)
+    array.each{ |v| fillet_side(v[0], v[1]) }
+  end
+
+  def apply_fillet(edge, value)
+    case edge
+    when 0
+      translate(y: -y/2.0+value, z: z/2.0-value) {
+        difference() {
+          translate(y:-value-PAD, z: value+PAD) { 
+            fillet_cube([x+2.0*PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          rotate(y: 90) { fillet_cylinder(x+4*PAD, value) }
+        }
+      }
+    when 1
+      translate(x: x/2.0-value, y: -y/2.0+value) {
+        difference() {
+          translate(x: value+PAD, y: -value-PAD) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, z+2.0*PAD])
+          }
+          fillet_cylinder(z+4*PAD,value)
+        }
+      }
+    when 2
+      translate(y: -y/2.0+value, z: -z/2.0+value) {
+        difference() {
+          translate(y: -value-PAD, z: -value-PAD) {
+            fillet_cube([x+2.0*PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          rotate(y: 90) {  fillet_cylinder(x+4*PAD,value) }
+        }
+      }
+    when 3
+      translate(x: -x/2.0+value, y: -y/2.0+value) {
+        difference() {
+          translate(x: -value-PAD, y: -value-PAD) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, z+2.0*PAD])
+          }
+          fillet_cylinder(z+4*PAD,value)
+        }
+      }
+    when 4
+      translate(x: -x/2.0+value, z: z/2.0-value) {
+        difference() {
+          translate(x: -value-PAD, z: value+PAD) {
+            fillet_cube([value*2.0+PAD, y+2.0*PAD, value*2.0+PAD])
+          }
+          rotate(y: 90, z: 90) { fillet_cylinder(y+4*PAD, value) }
+        }
+      }
+    when 5
+      translate(x: x/2.0-value, z: z/2.0-value) {
+        difference() {
+          translate(x: value+PAD, z: value+PAD) {
+            fillet_cube([value*2.0+PAD, y+2.0*PAD, value*2.0+PAD])
+          }
+          rotate(y: 90, z: 90) { fillet_cylinder(y+4*PAD, value) }
+        }
+      }
+    when 6
+      translate(x: x/2.0-value, z: -z/2.0+value) {
+        difference() {
+          translate(x: value+PAD, z: -value-PAD) {
+            fillet_cube([value*2.0+PAD, y+2.0*PAD, value*2.0+PAD])
+          }
+          rotate(y: 90, z: 90) {  fillet_cylinder(y+4*PAD, value) }
+        }
+      }
+    when 7
+      translate(x: -x/2.0+value, z: -z/2.0+value) {
+        difference() {
+          translate(x: -value-PAD, z: -value-PAD) {
+            fillet_cube([value*2.0+PAD, y+2.0*PAD, value*2.0+PAD])
+          }
+          rotate(y: 90, z: 90) { fillet_cylinder(y+4*PAD, value) }
+        }
+      }
+    when 8
+      translate(y: y/2.0-value, z: z/2.0-value) {
+        difference() {
+          translate(y: value+PAD, z: value+PAD) {
+            fillet_cube([x+2.0*PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          rotate(x: 90) { fillet_cylinder(x+4*PAD,value) }
+        }
+      }
+    when 9
+      translate(x: x/2.0-value, y: y/2.0-value) {
+        difference() {
+          translate(x: value+PAD, y: value+PAD) {
+            fillet_cube([value*2+PAD, value*2+PAD, z+2*PAD])
+          }
+          fillet_cylinder(z+4*PAD, value)
+        }
+      }
+    when 10
+      translate(y: y/2.0-value, z: -z/2.0+value) {
+        difference() {
+          translate(y: value+PAD, z: -value-PAD) {
+            fillet_cube([x+2.0*PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          rotate(x: 90) { fillet_cylinder(x+4*PAD,value) }
+        }
+      }
+    when 11
+      translate(x: -x/2.0+value, y: y/2.0-value) {
+        difference() {
+          translate(x: -value-PAD, y: value+PAD) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, z+2.0*PAD])
+          }
+          fillet_cylinder(z+4*PAD, value)
+        }
+      }
+    end
+  end
+
+  def fillet_corner(corner, value)
+    case corner
+    when 0
+      translate(v:[-x/2.0+value, -y/2.0+value, z/2.0-value]) {
+        difference() {
+          translate(v:[-value-PAD, -value-PAD, value+PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 1
+      translate(v:[x/2.0-value, -y/2.0+value, z/2.0-value]) {
+        difference() {
+          translate(v:[value+PAD, -value-PAD, value+PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 2
+      translate(v:[x/2.0-value, -y/2.0+value, -z/2.0+value]) {
+        difference() {
+          translate(v:[value+PAD, -value-PAD, -value-PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 3
+      translate(v:[-x/2.0+value, -y/2.0+value, -z/2.0+value]) {
+        difference() {
+          translate(v:[-value-PAD, -value-PAD, -value-PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 4
+      translate(v:[-x/2.0+value, y/2.0-value, z/2.0-value]) {
+        difference() {
+          translate(v:[-value-PAD, value+PAD, value+PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 5
+      translate(v:[x/2.0-value, y/2.0-value, z/2.0-value]) {
+        difference() {
+          translate(v: [value+PAD, value+PAD, value+PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 6
+      translate(v:[x/2.0-value, y/2.0-value, -z/2.0+value]) {
+        difference() {
+          translate(v:[value+PAD, value+PAD, -value-PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    when 7
+      translate(v:[-x/2.0+value, y/2.0-value, -z/2.0+value]) {
+        difference() {
+          translate(v:[-value-PAD, value+PAD, -value-PAD]) {
+            fillet_cube([value*2.0+PAD, value*2.0+PAD, value*2.0+PAD])
+          }
+          fillet_sphere(value)
+        }
+      }
+    end
+  end
+
+  def fillet_sphere(r)
+    sphere(r: r, fn: @smooth)
+  end
+
+  def fillet_cylinder(height, radius)
+    cylinder(r: radius, h: height, center: true, fn: @smooth)
+  end
+
+  def fillet_cube(size)
+    cube(size: size, center:true)
+  end
+
+  def greater_than_0(*args)
+    args.each { |v| return nil if v <= 0 }
+    return true
+  end
+
+  def auto_corner_fillet()
+    if greater_than_0(@fillet[0], @fillet[3], @fillet[4])
+      fillet = average(@fillet[0], @fillet[3], @fillet[4])
+      fillet_corner(0, fillet)
+    end
+    if greater_than_0(@fillet[0], @fillet[1], @fillet[5])
+      fillet = average(@fillet[0], @fillet[1], @fillet[5])
+      fillet_corner(1, fillet)
+    end
+    if greater_than_0(@fillet[1], @fillet[2], @fillet[6])
+      fillet = average(@fillet[1], @fillet[2], @fillet[6])
+      fillet_corner(2, fillet)
+    end
+    if greater_than_0(@fillet[2], @fillet[3], @fillet[7])
+      fillet = average(@fillet[2], @fillet[3], @fillet[7])
+      fillet_corner(3, fillet)
+    end
+    if greater_than_0(@fillet[4], @fillet[8], @fillet[11])
+      fillet = average(@fillet[4], @fillet[8], @fillet[11])
+      fillet_corner(4, fillet)
+    end
+    if greater_than_0(@fillet[5], @fillet[8], @fillet[9])
+      fillet = average(@fillet[5], @fillet[8], @fillet[9])
+      fillet_corner(5, fillet)
+    end
+    if greater_than_0(@fillet[6], @fillet[9], @fillet[10])
+      fillet = average(@fillet[6], @fillet[9], @fillet[10])
+      fillet_corner(6, fillet)
+    end
+    if greater_than_0(@fillet[7], @fillet[10], @fillet[11])
+      fillet = average(@fillet[7], @fillet[10], @fillet[11])
+      fillet_corner(7, fillet)
+    end    
+  end
+  
+  def average(*args)
+    args.inject(0.0) { |sum, el| sum + el } / args.size
+  end
+
+  def render(args={})
+    difference {
+      super
+      @fillet.each_with_index { |v, i| apply_fillet(i, v) if v > 0 }
+      auto_corner_fillet()
+    }
+  end
+end
+
+#cube = FilletCube.new(size:[5, 7, 8], center: true)
+#cube.fillet_sides([[0,1], [1,1], [2,1], [3,1], [4,1], [5,1]])
+#cube.render

data/examples/example001.rb

@@ -0,0 +1,33 @@
+require 'rubyscad'
+
+class Example001
+  include RubyScad
+
+  def initialize(args={})
+    @size = args.fetch(:size, 50).to_f
+    @hole = args.fetch(:hole, 25).to_f
+  end
+
+  def r_from_dia(d)
+    d / 2.0
+  end
+  
+  def rotcy(rot, r, h)
+    rotate(a: 90, v: rot)
+    cylinder(r: r, h: h, center: true)
+  end
+
+  def render
+    cy_r = r_from_dia(@hole)
+    cy_h = r_from_dia(@size * 2.5)
+
+    difference() {
+      sphere(r: r_from_dia(@size))
+      rotcy([0, 0, 0], cy_r, cy_h)
+      rotcy([1, 0, 0], cy_r, cy_h)
+      rotcy([0, 1, 0], cy_r, cy_h)
+    }    
+  end
+end
+
+Example001.new(size: ARGV.fetch(0, 50), hole: ARGV.fetch(1, 25)).render if __FILE__ == $0

data/examples/example001.scad

@@ -0,0 +1,11 @@
+//created with rubyscad 1.0
+
+difference() {
+   sphere(r = 25.000); 
+   rotate(a = 90, v = [0, 0, 0]) 
+   cylinder(r = 12.500, h = 62.500, center = true); 
+   rotate(a = 90, v = [1, 0, 0]) 
+   cylinder(r = 12.500, h = 62.500, center = true); 
+   rotate(a = 90, v = [0, 1, 0]) 
+   cylinder(r = 12.500, h = 62.500, center = true); 
+}

data/examples/example002.rb

@@ -0,0 +1,23 @@
+require 'rubyscad'
+
+module Example002
+  extend RubyScad
+
+  intersection() {
+    difference() {
+      union() {
+        cube(size: 30, center: true)
+        translate(z:-25)
+        cube(size: [15, 15, 50], center: true)
+      }
+      union() {
+        cube(size: [50, 10, 10], center: true)
+        cube(size: [10, 50, 10], center: true)
+        cube(size: [10, 10, 50], center: true)
+      }
+    }
+    translate(z: 5)
+    cylinder(h: 50, r1: 20, r2: 5, center: true)
+  }
+end
+

data/examples/example002.scad

@@ -0,0 +1,18 @@
+//created with rubyscad 1.0
+
+intersection() {
+   difference() {
+      union() {
+         cube(size = 30, center = true); 
+         translate(v = [0.000, 0.000, -25]) 
+         cube(size = [15, 15, 50], center = true); 
+      }
+      union() {
+         cube(size = [50, 10, 10], center = true); 
+         cube(size = [10, 50, 10], center = true); 
+         cube(size = [10, 10, 50], center = true); 
+      }
+   }
+   translate(v = [0.000, 0.000, 5]) 
+   cylinder(h = 50, r1 = 20, r2 = 5, center = true); 
+}

data/examples/example003.rb

@@ -0,0 +1,19 @@
+require 'rubyscad'
+
+module Example003
+  extend RubyScad
+
+  difference() {
+    union() {
+      cube(size: 30, center: true)
+      cube(size: [40, 15, 15], center: true)
+      cube(size: [15, 40, 15], center: true)
+      cube(size: [15, 15, 40], center: true)
+    }
+    union() {
+      cube(size: [50, 10, 10], center: true)
+      cube(size: [10, 50, 10], center: true)
+      cube(size: [10, 10, 50], center: true)
+    }
+  }
+end

data/examples/example003.scad

@@ -0,0 +1,15 @@
+//created with rubyscad 1.0
+
+difference() {
+   union() {
+      cube(size = 30, center = true); 
+      cube(size = [40, 15, 15], center = true); 
+      cube(size = [15, 40, 15], center = true); 
+      cube(size = [15, 15, 40], center = true); 
+   }
+   union() {
+      cube(size = [50, 10, 10], center = true); 
+      cube(size = [10, 50, 10], center = true); 
+      cube(size = [10, 10, 50], center = true); 
+   }
+}

data/examples/example004.rb

@@ -0,0 +1,11 @@
+require "rubyscad"
+
+module Example004
+  extend RubyScad
+
+  difference() {
+    cube(size: 30, center: true)
+    sphere(r: 20)
+  }
+end
+

data/examples/example004.scad

@@ -0,0 +1,6 @@
+//created with rubyscad 1.0
+
+difference() {
+   cube(size = 30, center = true); 
+   sphere(r = 20); 
+}

data/examples/example005.rb

@@ -0,0 +1,22 @@
+require "rubyscad"
+
+module Example005
+  extend RubyScad
+
+  translate(z: -120) {
+    difference() {
+      cylinder(h: 50, r: 100)
+      translate(z: 10); cylinder(h: 50, r: 80)
+      translate(v: [100, 0, 35]); cube(size: 50, center: true)
+    }
+
+    (0..5).each do |i|
+      echo(360*i/6, Math.sin((360*i/6).radians)*80, Math.cos((360*i/6).radians)*80)
+      translate(v:[Math.sin((360*i/6).radians)*80, Math.cos((360*i/6).radians)*80, 0])
+      cylinder(h: 200, r: 10)
+    end
+
+    translate(z: 200)
+    cylinder(h: 80, r1: 120, r2: 0)
+  }
+end