solidruby 0.1.0

data/lib/solidruby/rubyscad_bridge.rb

@@ -0,0 +1,376 @@
+#    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/>.
+#
+#
+# This code is based on RubyScad (https://github.com/cjbissonnette/RubyScad)
+# which is GPLv3
+#
+require 'matrix'
+
+module SolidRuby
+  class RubyScadBridge
+    START_BLOCK = '{'.freeze
+    END_BLOCK   = '}'.freeze
+    TAB_SIZE    = 3
+    PAD         = 0.01
+    FP_P        = 3
+
+    CUBE_STR            = 'cube(%<args>s);'.freeze
+    SPHERE_STR          = 'sphere(%<args>s);'.freeze
+    CYLINDER_STR        = 'cylinder(%<args>s);'.freeze
+    POLYHEDRON_STR      = 'polyhedron(%<args>s);'.freeze
+    SQUARE_STR          = 'square(%<args>s);'.freeze
+    CIRCLE_STR          = 'circle(%<args>s);'.freeze
+    POLYGON_STR         = 'polygon(%<args>s);'.freeze
+    TRANSLATE_STR       = 'translate(%<args>s)'.freeze
+    ROTATE_STR          = 'rotate(%<args>s)'.freeze
+    SCALE_STR           = 'scale(%<args>s)'.freeze
+    MIRROR_STR          = 'mirror(%<args>s)'.freeze
+    MULTMATRIX_STR      = 'multmatrix(%<args>s)'.freeze
+    COLOR_STR           = 'color(%<args>s)'.freeze
+    UNION_STR           = 'union(%<args>s)'.freeze
+    DIFFERENCE_STR      = 'difference(%<args>s)'.freeze
+    INTERSECTION_STR    = 'intersection(%<args>s)'.freeze
+    RENDER_STR          = 'render(%<args>s)'.freeze
+    MINKOWSKI_STR       = 'minkowski(%<args>s)'.freeze
+    HULL_STR            = 'hull(%<args>s)'.freeze
+    BACKGROUND_STR      = '%'.freeze
+    DEBUG_STR           = '#'.freeze
+    ROOT_STR            = '!'.freeze
+    DISABLE_STR         = '*'.freeze
+    IMPORT_STR          = 'import(%<args>s);'.freeze
+    SURFACE_STR         = 'surface(%<args>s);'.freeze
+    LINEAR_EXTRUDE_STR  = 'linear_extrude(%<args>s)'.freeze
+    ROTATE_EXTRUDE_STR  = 'rotate_extrude(%<args>s)'.freeze
+    PROJECTION_STR      = 'projection(%<args>s)'.freeze
+    TEXT_STR      = 'text(%<args>s);'.freeze
+
+    INCLUDE_STR = 'include <%<file>s>'.freeze
+    USE_STR     = 'use <%<file>s>'.freeze
+    ECHO_STR    = 'echo(%<string>s);'.freeze
+    FA_STR      = '$fa = %<value>s;'.freeze
+    FS_STR      = '$fs = %<value>s;'.freeze
+    FN_STR      = '$fn = %<value>s;'.freeze
+
+    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 = {})
+      if args.include?(:d)
+        args[:r] = args[:d] / 2.0
+        args.delete(:d)
+      end
+      if args.include?(:d1)
+        args[:r1] = args[:d1] / 2.0
+        args.delete(:d1)
+      end
+      if args.include?(:d2)
+        args[:r2] = args[:d2] / 2.0
+        args.delete(:d2)
+      end
+      format_command CYLINDER_STR, args
+    end
+
+    def text(args = {})
+      format_command TEXT_STR, args
+    end
+
+    def rotate(args = {}, &block)
+      vector_input(args, :a)
+      format_command ROTATE_STR, args, &block
+    end
+
+    def translate(args = {}, &block)
+      delete_from(args, :z) if args[:z] == 0
+      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)
+      if args.include?(:color)
+        args[:color] = "\"#{args[:color]}\""
+      else
+        args[:color] = [args.fetch(:r, 0), args.fetch(:g, 0), args.fetch(:b, 0), args.fetch(:a, 1)].to_s
+      end
+      delete_from(args, :r, :g, :b, :a)
+      format_command(COLOR_STR, args[:color], &block)
+    end
+
+    def format_command(cmd_str, args = {}, &block)
+      if args.is_a? String
+        arg_str = args
+      else
+        arg_str = args.collect do
+          |k, v| "#{format_key(k)} = #{format_value(v)}"
+        end
+        .sort_by{ |x| ['$fn', '$fa', '$fs', 'cen', 'con'].include?(x[0..2]) ? ('z' + x) : x }
+        .join(', ')
+      end
+      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.nil?
+        "nil"
+      elsif var.is_a?(Vector) || var.is_a?(Matrix) || var.is_a?(Array)
+        res = []
+        var.to_a.each do |v|
+          res << format_value(v)
+        end
+        res.to_s.gsub('"', "").gsub('\\', '')
+      elsif var.is_a? String
+        '"' + var + '"'
+      elsif var.is_a? Float
+        "%.#{FP_P}f" % var.round(FP_P).to_s
+      else
+        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 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)
+      str
+    end
+
+    def format_output(str)
+      str
+    end
+
+    def format_block(output_str)
+      output_str
+    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
+    end
+
+    def self.included(_mod)
+      start_output
+    end
+
+    start_output if __FILE__ == $PROGRAM_NAME
+
+    def lookup(x, points)
+      xmin = 0.0
+      xmax = 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
+      points[xmin] + (((x - xmin) * (points[xmax] - points[xmin])) / (xmax - xmin))
+    end
+
+    def dxf_cross(_args = {})
+      0.0
+    end
+
+    def dxf_dim(_args = {})
+      0.0
+    end
+  end
+end

data/lib/solidruby/screw_thread.rb

@@ -0,0 +1,170 @@
+#    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::ScrewThreads
+  class ScrewThread
+    # I would name this Thread but that's already taken by something else
+
+    attr_accessor :x, :y, :z, :size, :depth, :face
+
+    def initialize(args = {})
+      @x = args[:x] || 0
+      @y = args[:y] || 0
+      @z = args[:z] || 0
+      @depth = args[:depth]
+      @size = args[:size]
+      @face = args[:face] || :top
+    end
+
+    def rotation
+      case @face.to_s
+      when 'top'
+        {}
+      when 'bottom'
+        { y: 180 }
+      when 'left'
+        { y: -90 }
+      when 'right'
+        { y: 90 }
+      when 'front' # checkme
+        { x: 90 }
+      when 'back'
+        { x: -90 }
+      end
+    end
+
+    def show
+      cylinder(d: @size, h: @depth).rotate(rotation).translate(x: @x, y: @y, z: @z).color(r: 130, g: 130, b: 130)
+    end
+
+    def output
+      show
+    end
+
+    def orientation_swap_to(coords, rotation)
+      return [coords[0], coords[2], -coords[1]] if rotation[:x].to_i == -90
+      return [coords[0], -coords[2], coords[1]] if rotation[:x].to_i == 90
+      return [coords[2], coords[1], coords[0]] if rotation[:y].to_i == -90
+      return [-coords[2], coords[1], -coords[0]] if rotation[:y].to_i == 90
+
+      coords
+    end
+
+    def position_on(other_thread, rotation = {})
+      if other_thread.is_a? Bolt
+        # we assume that a bolt is always centered and center the object on
+        # the screwthread position
+        { x: -@x, y: -@y, z: -@z }
+      else
+        # on a screwthread find out its position and orientation
+        oc = other_thread.x, other_thread.y, other_thread.z
+        oc = orientation_swap_to(oc, rotation)
+        { x: @x - oc[0], y: @y - oc[1], z: @z - oc[2] }
+      end
+    end
+  end
+
+  def create_bolts(face, obj1, obj2, args = {})
+    # make a obj1-=obj2 with bolts corresponding to the height of obj1
+
+    if face.nil? || obj1.nil? || obj2.nil?
+      raise 'usage: create_bolts(face,obj1,obj2,args={})  - args can include (obj1.)height and bolt_height'
+      return
+    end
+
+    # we need to know obj1 height (if not supplied by user)
+    #TODO: Rescuing like this is not good practise
+    height ||= args[:height]
+    case face.to_s
+    when 'top'
+      height ||= obj1.z rescue nil
+    when 'bottom'
+      height ||= obj1.z rescue nil
+    when 'left'
+      height ||= obj1.x rescue nil
+    when 'right'
+      height ||= obj1.x rescue nil
+    when 'front'
+      height ||= obj1.y rescue nil
+    when 'back'
+      height ||= obj1.y rescue nil
+    end
+    height ||= obj1.height rescue nil
+
+    if height.nil?
+      raise "the object we're substracting from doesn't have a height defined; please define manually"
+      return
+    end
+
+    # lets check if the obj2 responds to the threads_[face] method
+
+    meth = "threads_#{face}"
+
+    unless obj2.respond_to?(meth)
+      raise "The object you're trying to get bolts from doesn't supply any on the face '#{face}'. Please add a method #{meth} to this object"
+      return
+    end
+    holes = obj2.send(meth)
+
+    return if holes.nil?
+
+    # let the user either define bolt_heights as integer, array or none (will be guessed)
+    if args[:bolt_height].is_a? Array
+      bolt_heights = args[:bolt_height]
+      if bolt_heights.size != holes.size
+        raise "object has #{holes.size} threads for bolts but you supplied #{bolt_heights.size}"
+        return
+      end
+    else
+      bolt_heights = []
+      holes.each do |hole|
+        bolt_heights << if args[:bolt_height]
+                          args[:bolt_height]
+                        else
+                          (height + hole.depth).floor
+                        end
+      end
+    end
+
+    ret = []
+    holes.each_with_index do |hole, i|
+      bolt = Bolt.new(hole.size, bolt_heights[i], washer: args[:washer])
+      case face
+      when 'top'
+        bolt.transformations << Rotate.new(x: 180)
+        bolt.transformations << Translate.new(x: hole.x, y: hole.y, z: hole.z + height)
+      when 'bottom'
+        bolt.transformations << Translate.new(x: hole.x, y: hole.y, z: hole.z)
+      when 'left'
+        bolt.transformations << Rotate.new(y: 90)
+        bolt.transformations << Translate.new(x: hole.x, y: hole.y, z: hole.z)
+      when 'right'
+        bolt.transformations << Rotate.new(y: -90)
+        bolt.transformations << Translate.new(x: hole.x + height, y: hole.y, z: hole.z)
+      when 'front'
+        bolt.transformations << Rotate.new(x: -90)
+        bolt.transformations << Translate.new(x: hole.x, y: hole.y, z: hole.z)
+      when 'back'
+        bolt.transformations << Rotate.new(x: 90)
+        bolt.transformations << Translate.new(x: hole.x, y: hole.y + height, z: hole.z)
+      end
+      bolt.transformations += obj2.transformations unless obj2.transformations.nil?
+
+      ret << bolt
+    end
+
+    ret
+  end
+end