solidruby 0.1.0

data/lib/solidruby/csg_modelling/intersection.rb

@@ -0,0 +1,24 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModelling
+  class Intersection < CSGModelling
+  end
+
+  def *(args)
+    return args if nil?
+    Intersection.new(self, args)
+  end
+end

data/lib/solidruby/csg_modelling/minkowski.rb

@@ -0,0 +1,23 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModelling
+  class Minkowski < CSGModelling
+  end
+
+  def minkowski(*parts)
+    Minkowski.new(*parts)
+  end
+end

data/lib/solidruby/csg_modelling/union.rb

@@ -0,0 +1,41 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModelling
+  class Union < CSGModelling
+  end
+
+  def +(args)
+    return args if nil?
+    if args.is_a? Array
+      r = self
+      args.each do |a|
+        r = Union.new(r, a)
+      end
+      r
+    else
+      optimize_union(self, args)
+    end
+  end
+
+  def optimize_union(top, child)
+    if top.is_a?(Union) && (!child.is_a? Union) && top.transformations.empty?
+      top.children << child
+      top
+    else
+      Union.new(top, child)
+    end
+  end
+end

data/lib/solidruby/csg_modifiers/color.rb

@@ -0,0 +1,41 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModifiers
+  class Color < CSGModifier
+    def initialize(object, attributes, opacity = nil)
+      @operation = 'color'
+      if attributes.is_a? String
+        attributes = "\"#{attributes}\""
+        attributes += ", #{opacity}" unless opacity.nil?
+      elsif attributes.is_a? Hash
+        attributes[:a] ||= 255
+
+        r = attributes[:r] / 255.0
+        g = attributes[:g] / 255.0
+        b = attributes[:b] / 255.0
+        a = attributes[:a] / 255.0
+        attributes = {c: [r, g, b], alpha: a}
+      end
+
+      super(object, attributes)
+    end
+
+  end
+
+  def color(args, opacity = nil)
+    Color.new(self, args, opacity)
+  end
+end

data/lib/solidruby/csg_modifiers/csg_modifier.rb

@@ -0,0 +1,50 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModifiers
+  class CSGModifier < SolidRuby::SolidRubyObject
+    def initialize(object, attributes)
+      super(attributes)
+      @transformations = []
+      @children = [object]
+      @attributes = attributes
+    end
+
+    def to_rubyscad
+      att = @attributes
+      if att.is_a? Hash
+        att = @attributes.select {|k, v| !v.nil? }.collect do |k, v|
+          sv = RubyScadBridge.new.format_value(v)
+          "#{k} = #{sv}"
+        end.sort_by{ |x| x[0] == 'f' ? ('z' + x) : x }
+      end
+
+      att = att.join(', ') if att.is_a? Array
+
+      #	Apparently this doesn't work for CSGModifiers, like it does for other things in RubyScad?
+      # also this is a dirty, dirty hack.
+      att = att.gsub('fn', '$fn').gsub('$$', '$')
+      ret = "#{@operation}(#{att}){"
+      @children ||= []
+      @children.each do |child|
+        begin
+          ret += child.walk_tree
+        rescue NoMethodError
+        end
+      end
+      ret += '}'
+    end
+  end
+end

data/lib/solidruby/csg_modifiers/linear_extrude.rb

@@ -0,0 +1,34 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModifiers
+  class LinearExtrude < CSGModifier
+    alias_attr :height
+    alias_attr :convexity, :co
+    alias_attr :center, :ce
+    alias_attr :twist
+    alias_attr :slices, :sl
+    alias_attr :scale, :sc
+
+    def initialize(object, args)
+      @operation = 'linear_extrude'
+      super(object, args)
+    end
+  end
+
+  def linear_extrude(args)
+    LinearExtrude.new(self, args)
+  end
+end

data/lib/solidruby/csg_modifiers/projection.rb

@@ -0,0 +1,29 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModifiers
+  class Projection < CSGModifier
+    alias_attr :cut
+
+    def initialize(object, args)
+      @operation = 'projection'
+      super(object, args)
+    end
+  end
+
+  def projection(args = {})
+    Projection.new(self, args)
+  end
+end

data/lib/solidruby/csg_modifiers/rotate_extrude.rb

@@ -0,0 +1,30 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::CSGModifiers
+  class RotateExtrude < CSGModifier
+    alias_attr :angle
+    alias_attr :convexity
+
+    def initialize(object, args)
+      @operation = 'rotate_extrude'
+      super(object, args)
+    end
+  end
+
+  def rotate_extrude(args = {})
+    RotateExtrude.new(self, args)
+  end
+end

data/lib/solidruby/extra.rb

@@ -0,0 +1,58 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+
+module SolidRuby::Extras
+
+  def knurl(y)
+    x = 1.5
+    height = 1.5
+    res = cube([x, y, height])
+    res -= cylinder(d: 0.9, h: height * 1.42, fn: 16).rotate(y: 45).translate(x: 0)
+    res -= cylinder(d: 0.9, h: height * 1.42, fn: 16).rotate(y: -45).translate(x: 1.5)
+    res
+  end
+
+  def knurled_cube(size)
+    x = size[0]
+    y = size[1]
+    z = size[2]
+    res = nil
+
+    (x / 1.5).ceil.times do |i|
+      (z / 1.5).ceil.times do |f|
+        res += knurl(y).translate(x: i * 1.5, z: f * 1.5)
+      end
+    end
+
+    res *= cube([x, y, z])
+
+    res
+  end
+
+  def knurled_cylinder(args = {})
+    res = cylinder(args)
+    height = args[:h]
+    r = args[:d] / 2.0
+
+    24.times do |_i|
+      (height / 2).ceil.times do |f|
+        res -= cylinder(d: 0.9, h: height * 2).rotate(y: 45).translate(y: -r, z: f * 2)
+        res -= cylinder(d: 0.9, h: height * 2).rotate(y: -45).translate(y: -r, z: f * 2)
+      end
+      res.rotate(z: 15)
+    end
+    res
+  end
+end

data/lib/solidruby/helpers/chamfer.rb

@@ -0,0 +1,27 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::Helpers
+   #Helper method for creating chamfers - basically just an extruded triangle
+   #that can be subtracted from an edge
+  def chamfer(args={})
+    height = args[:height] || args[:h] || 0
+    length = args[:length] || args[:l] || 0
+
+    t = triangle(a: height, alpha: 90, beta: 45)
+
+    return t.linear_extrude(height: length)
+  end
+end

data/lib/solidruby/helpers/fillet.rb

@@ -0,0 +1,28 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::Helpers
+  def fillet(args)
+    @radius = args[:r] || args[:radius]
+    @height = args[:h] || args[:height]
+    @fn = args[:fn] || 64
+
+    res = cube(@radius*2, @radius*2, @height+0.02).translate(z: -0.01) -
+    cylinder(r: @radius, h: @height + 0.04, fn: @fn)
+      .translate(z: -0.02)
+
+    res.translate(x: -@radius, y: -@radius)
+  end
+end

data/lib/solidruby/helpers/position.rb

@@ -0,0 +1,267 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    SolidRuby is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::Helpers
+
+  def corners(face = :top)
+    [
+      {face: face, edge: :top, corner: :left},
+      {face: face, edge: :top, corner: :right},
+      {face: face, edge: :bottom, corner: :left},
+      {face: face, edge: :bottom, corner: :right},
+    ]
+  end
+
+  def is_vertical?(face, edge)
+    if [:top, :bottom].include? face
+      false
+    elsif [:top, :bottom].include? edge
+      false
+    else
+      true
+    end
+  end
+
+  def is_horizontal?(face, edge)
+    !is_vertical?(face, edge)
+  end
+
+  def is_x_dir?(face, edge)
+    if is_vertical?(face, edge)
+      false
+    elsif [:front, :back, :top, :bottom].include?(face) &&
+          [:top, :bottom].include?(edge)
+      true
+    else
+      false
+    end
+  end
+
+  def is_y_dir?(face, edge)
+    return false if is_x_dir?(face, edge) || is_vertical?(face, edge)
+    true
+  end
+
+  def normalise_edges(args={})
+    faces = {}
+
+    args.each do |key, val|
+      if [:front, :back, :left, :right, :top, :bottom].include? key
+        val = [val] unless val.is_a? Array
+        faces[key] = val
+        next
+      elsif key == :edges
+        if val == :vertical
+          faces[:front] = [:left, :right]
+          faces[:back] = [:left, :right]
+        elsif val == :horizontal
+          faces[:front] = [:top, :bottom]
+          faces[:right] = [:top, :bottom]
+          faces[:left] = [:top, :bottom]
+          faces[:back] = [:top, :bottom]
+        elsif val == :all
+          faces[:front] = [:top, :bottom, :left, :right]
+          faces[:right] = [:top, :bottom]
+          faces[:left] = [:top, :bottom]
+          faces[:back] = [:top, :bottom, :left, :right]
+        end
+      end
+    end
+    faces
+  end
+
+  def translations_for_edge(args={})
+    tolerance = args[:tolerance] || 0.01
+    trans = []
+    args[:faces].each do |face, edges|
+      edges.each do |edge|
+        res = {}
+        res[:z_rot] = 0
+        res[:y_rot] = 0
+        res[:x_rot] = 0
+        res[:x_trans] = 0
+        res[:y_trans] = 0
+        res[:length] = args[:z]
+        res[:z_trans] = -res[:length]/2.0 - (tolerance*2)
+
+        #position on edge
+        if Helpers::is_horizontal?(face, edge)
+          res[:y_rot] = 90
+          res[:z_trans] = 0
+        end
+
+        if is_x_dir?(face, edge)
+          res[:length] = args[:x]
+          res[:x_trans] = -res[:length] / 2.0 - (tolerance*2)
+        elsif is_y_dir?(face, edge)
+          res[:length] = args[:y]
+          res[:y_trans] = res[:length] / 2.0
+          res[:x_rot] = 90
+        end
+
+        #rotate to match edge
+        rot_matrix = {
+          [:top, :top] => 90,
+          [:top, :left] => 180,
+          [:top, :right] => 90,
+          [:top, :bottom] => 180,
+
+          [:bottom, :top] => 270,
+          [:bottom, :left] => 270,
+          [:bottom, :right] => 0,
+          [:bottom, :bottom] => 0,
+
+          [:left, :top] => 180,
+          [:left, :left] => 90,
+          [:left, :right] => 180,
+          [:left, :bottom] => 270,
+
+          [:right, :top] => 90,
+          [:right, :left] => 270,
+          [:right, :right] => 0,
+          [:right, :bottom] => 0,
+
+          [:front, :top] => 180,
+          [:front, :left] => 180,
+          [:front, :right] => 270,
+          [:front, :bottom] => 270,
+
+          [:back, :top] => 90,
+          [:back, :left] => 0,
+          [:back, :right] => 90,
+          [:back, :bottom] => 0,
+        }
+
+        res[:z_rot] = rot_matrix[[face, edge]]
+
+        point = args[:onto].get_point_on(face: face, edge: edge)
+
+        if tolerance > 0
+          point[:x] = point[:x] > 0 ? point[:x] + tolerance : point[:x] - tolerance
+          point[:y] = point[:y] > 0 ? point[:y] + tolerance : point[:y] - tolerance
+          point[:z] = point[:z] > 0 ? point[:z] + tolerance : point[:z] - tolerance
+        end
+
+        res[:x_trans] += point[:x]
+        res[:y_trans] += point[:y]
+        res[:z_trans] += point[:z]
+
+        trans << res
+      end
+    end
+
+    trans
+  end
+
+  def calculate_point_on(args = {})
+    face = args[:face] || :top
+    edge = args[:edge] || :center
+    corner = args[:corner] || :center
+    face_offset = args[:face_offset] || 0
+    edge_offset = args[:edge_offset] || 0
+    corner_offset = args[:corner_offset] || 0
+
+    vert_axis = :z
+    horiz_axis = :x
+    vert_dir = 1
+    horiz_dir = 1
+
+    pos = case face
+    when :top
+      vert_axis = :y
+      horiz_dir = -1
+      {x: args[:x] / 2.0, y: args[:y] / 2.0, z: args[:z] + face_offset}
+    when :bottom
+      vert_axis = :y
+      horiz_dir = -1
+      vert_dir = -1
+      { x: args[:x] / 2.0, y: args[:y] / 2.0, z: -face_offset}
+    when :left
+      horiz_axis = :y
+      { x: face_offset, y: args[:y] / 2.0, z: args[:z] / 2.0 }
+    when :right
+      horiz_axis = :y
+      horiz_dir = -1
+      { x: args[:x] + face_offset, y: args[:y] / 2.0, z: args[:z] / 2.0 }
+    when :front
+      horiz_dir = -1
+      { x: args[:x] / 2.0, y: -face_offset, z: args[:z] / 2.0 }
+    when :back
+      { x: args[:x] / 2.0, y: args[:y] + face_offset, z: args[:z] / 2.0 }
+    when :center
+      horiz_dir = -1
+      { x: args[:x] / 2.0, y: args[:y] / 2.0, z: args[:z] / 2.0 }
+    end
+
+    return pos if pos.nil?
+
+    pos[:x] -= args[:x] / 2.0 if args[:centered]
+    pos[:y] -= args[:y] / 2.0 if args[:centered]
+    pos[:z] -= args[:z] / 2.0 if args[:centered_z]
+
+    args[:transformations].each do |t|
+      pos[:x] += t.x
+      pos[:y] += t.y
+      pos[:z] += t.z
+    end
+
+    #pos is now center of the given face, move to the given side
+    h_change = case horiz_axis
+    when :x
+      args[:x] / 2.0
+    when :y
+      args[:y] / 2.0
+    end
+
+    v_change = case vert_axis
+    when :y
+      args[:y] / 2.0
+    else
+      args[:z] / 2.0
+    end
+
+    case edge
+    when :top
+      pos[vert_axis] += (v_change * vert_dir)
+      pos[vert_axis] += (edge_offset * vert_dir)
+    when :bottom
+      pos[vert_axis] -= (v_change * vert_dir)
+      pos[vert_axis] -= (edge_offset * vert_dir)
+    when :left
+      pos[horiz_axis] += (h_change * horiz_dir)
+      pos[horiz_axis] += (edge_offset * horiz_dir)
+    when :right
+      pos[horiz_axis] -= (h_change * horiz_dir)
+      pos[horiz_axis] -= (edge_offset * horiz_dir)
+    end
+
+    case corner
+    when :top
+      pos[vert_axis] += (v_change * vert_dir)
+      pos[vert_axis] += (corner_offset * vert_dir)
+    when :bottom
+      pos[vert_axis] -= (v_change * vert_dir)
+      pos[vert_axis] -= (corner_offset * vert_dir)
+    when :left
+      pos[horiz_axis] += (h_change * horiz_dir)
+      pos[horiz_axis] += (corner_offset * horiz_dir)
+    when :right
+      pos[horiz_axis] -= (h_change * horiz_dir)
+      pos[horiz_axis] -= (corner_offset * horiz_dir)
+    end
+
+    pos
+  end
+end