rubyscad 1.0.6 → 1.0.7

data/Rakefile

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

data/examples/BasicCube.rb

@@ -1,50 +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
+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

@@ -1,96 +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
+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

@@ -1,317 +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
+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