solidruby 0.1.0

data/lib/solidruby/helpers/rounded_cube.rb

@@ -0,0 +1,37 @@
+#    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 rounded_cube(args = {}, y = nil, z = nil)
+    c = cube(args, y, z)
+    r = args[:r]
+    sx = c.x - r * 2
+    sy = c.y - r * 2
+    sz = c.z - r
+
+    res = hull(
+      sphere(r: r).translate(z: r),
+      sphere(r: r).translate(z: sz),
+      sphere(r: r).translate(x: sx, z: sz),
+      sphere(r: r).translate(x: sx, y: sy, z: sz),
+      sphere(r: r).translate(y: sy, z: sz),
+      sphere(r: r).translate(x: sx, z: r),
+      sphere(r: r).translate(y: sy, z: r),
+      sphere(r: r).translate(x: sx, y: sy, z: r)
+    ).translate(x: r, y: r)
+
+    res
+  end
+end

data/lib/solidruby/helpers/triangle.rb

@@ -0,0 +1,167 @@
+#    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 class for creating triangles, given three inputs
+  # (at least 1 side + angles)
+  #The triangle can then either be used as a Polygon,
+  #or it can be thrown away and used just for calcuation of the triangle
+  #order is assumed as follows:
+  # @a is opposite @alpha, @b is opposite @beta, @c is opposite @gamma
+  # Angles go clockwise with @alpha at the origin
+  # Sides go clockwise with @a along the X axis, and @c along Y
+  class Triangle < SolidRuby::Primitives::Polygon
+    attr_accessor :alpha, :beta, :gamma, :a, :b, :c, :has_alt_solution
+    def initialize(args = {})
+      use_alt_solution = args[:alt_solution] || false
+
+      if args.reject{|k| k == :alt_solution}.count != 3
+        raise "Triangle requires exactly 3 inputs"
+      elsif args[:a].nil? && args[:b].nil? && args[:c].nil?
+        raise "Triangle requires at least 1 side length"
+      end
+
+      #try to solve twice to see if we have two solutions
+      sol_count = 0
+      solution = solve(args, false)
+      sol_count += 1 unless solution.nil?
+      solution_alt = solve(args, true)
+      sol_count += 1 unless solution_alt.nil?
+
+      raise "Could not solve triangle." if sol_count == 0
+
+      @has_alt_solution = sol_count == 2 ? true : false
+
+      if use_alt_solution
+        update(solution_alt)
+      else
+        update(solution)
+      end
+
+      #consturct triangle polygon
+      args = {points: [
+        [0.0, 0.0],
+        [@b, 0.0],
+        [@c * Math.cos(radians(@alpha)), height(:beta)],
+        [0.0, 0.0]]}
+
+      super(args)
+    end
+
+    def height(angle)
+      case angle
+      when :alpha
+        ang = @beta
+        side = @c
+      when :beta
+        ang = @alpha
+        side = @c
+      else
+        ang = @alpha
+        side = @b
+      end
+      Math.sin(radians(ang)) * side.to_f
+    end
+
+private
+    def update(params)
+      @alpha = params[:alpha]
+      @beta = params[:beta]
+      @gamma = params[:gamma]
+      @a = params[:a]
+      @b = params[:b]
+      @c = params[:c]
+    end
+    #Solve for any missing angles/sides
+    def solve(triangle_params, alt_solution)
+      alpha = triangle_params[:alpha]
+      beta = triangle_params[:beta]
+      gamma = triangle_params[:gamma]
+      a = triangle_params[:a]
+      b = triangle_params[:b]
+      c = triangle_params[:c]
+
+      #find side for SAS case
+      a = solve_side_from_single_angle(b, c, alpha) if a.nil?
+      b = solve_side_from_single_angle(a, c, beta) if b.nil?
+      c = solve_side_from_single_angle(a, b, gamma) if c.nil?
+
+      #find one angle (SSS case)
+      alpha = solve_angle_from_sides(b, c, a) if alpha.nil?
+      beta = solve_angle_from_sides(a, c, b) if beta.nil?
+      gamma = solve_angle_from_sides(a, b, c) if gamma.nil?
+
+      #now we know at least one angle, find the next one (SSA case)
+      alpha = solve_angle_from_angle(a, b, beta, alt_solution) if alpha.nil?
+      alpha = solve_angle_from_angle(a, c, gamma, alt_solution) if alpha.nil?
+      beta = solve_angle_from_angle(b, a, alpha, alt_solution) if beta.nil?
+      beta = solve_angle_from_angle(b, c, gamma, alt_solution) if beta.nil?
+      gamma = solve_angle_from_angle(c, a, alpha, alt_solution) if gamma.nil?
+      gamma = solve_angle_from_angle(c, b, beta, alt_solution) if gamma.nil?
+
+      #now we know at least two angles, solve the third one
+      alpha = sub_angles(beta, gamma) if alpha.nil?
+      beta = sub_angles(alpha, gamma) if beta.nil?
+      gamma = sub_angles(alpha, beta) if gamma.nil?
+
+      #we know all the angles, now find any unknown sides
+      a = solve_side(alpha, b, beta) if a.nil?
+      a = solve_side(alpha, c, gamma) if a.nil?
+      b = solve_side(beta, a, alpha) if b.nil?
+      b = solve_side(beta, c, gamma) if b.nil?
+      c = solve_side(gamma, a, alpha) if c.nil?
+      c = solve_side(gamma, b, beta) if c.nil?
+
+      return nil if a.nil? || b.nil? || c.nil? || alpha.nil? || beta.nil? || gamma.nil?
+      {a: a, b: b, c: c, alpha: alpha, beta: beta, gamma: gamma}
+    end
+
+    def sub_angles(angle1, angle2)
+      return nil if angle1.nil? || angle2.nil?
+      180 - angle1 - angle2
+    end
+
+    def solve_angle_from_sides(adj_side, adj_side2, opp_side)
+      return nil if adj_side.nil? || adj_side2.nil? || opp_side.nil? ||
+        adj_side == 0 || adj_side2 == 0 || opp_side == 0
+
+      degrees(Math.acos((adj_side**2 + adj_side2**2 - opp_side**2) / (2.0 * adj_side * adj_side2)))
+    end
+
+    def solve_angle_from_angle(opp_side, adj_side, adj_angle, alt_solution)
+      return nil if opp_side.nil? || adj_side.nil? || adj_angle.nil?
+
+      res = degrees(Math.asin(opp_side * Math.sin(radians(adj_angle)) / adj_side))
+      res = 180 - res if alt_solution
+      res
+    end
+
+    def solve_side_from_single_angle(side1, side2, angle)
+      return nil if side1.nil? || side2.nil? || angle.nil?
+
+      Math.sqrt(side1**2 + side2**2 - 2 * side1 * side2 * Math.cos(radians(angle)))
+    end
+
+    def solve_side(opp_angle, adj_side, adj_opp_angle)
+      return nil if opp_angle.nil? || adj_side.nil? || adj_opp_angle.nil?
+
+      (Math.sin(radians(opp_angle)) * adj_side)/Math.sin(radians(adj_opp_angle))
+    end
+  end
+
+  def triangle(args)
+    Triangle.new(args)
+  end
+end

data/lib/solidruby/primitives/circle.rb

@@ -0,0 +1,26 @@
+#    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::Primitives
+  class Circle < Primitive
+    def to_rubyscad
+      RubyScadBridge.new.circle(@attributes)
+    end
+  end
+
+  def circle(args)
+    Circle.new(args)
+  end
+end

data/lib/solidruby/primitives/cube.rb

@@ -0,0 +1,123 @@
+#    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::Primitives
+  class Cube < Primitive
+    attr_accessor :x, :y, :z
+
+    def initialize(args={}, y = nil, z = nil)
+      if args.is_a? Array
+        args = { x: args[0], y: args[1], z: args[2] }
+      elsif args.is_a?(Hash) && args[:size]
+        args[:x] ||= args[:size][0] || 0
+        args[:y] ||= args[:size][1] || 0
+        args[:z] ||= args[:size][2] || 0
+      elsif args.is_a? Numeric
+        x = args
+        y ||= x
+        z ||= y# = x if y.nil? && z.nil?
+        args = { x: x, y: y, z: z }
+      end
+      @centered = args.delete(:center) || args.delete(:c)
+
+      @x = args[:x]
+      @y = args[:y] || @x
+      @z = args[:z] || @y
+      super(args)
+    end
+
+    def center_xy
+      @transformations << Translate.new(x: -@x / 2.0, y: -@y / 2.0)
+      self
+    end
+
+    def center_x
+      @transformations << Translate.new(x: -@x / 2.0)
+      self
+    end
+
+    def center_y
+      @transformations << Translate.new(y: -@y / 2.0)
+      self
+    end
+
+    def center_z
+      @transformations << Translate.new(z: -@z / 2.0)
+      self
+    end
+
+    def center
+      @centered = true
+      self
+    end
+
+    def centered?
+      @centered
+    end
+
+    def chamfer(args = {})
+      faces = normalise_edges(args)
+      height = args[:h] || args[:height]
+      trans = translations_for_edge(onto: self, faces: faces, x: @x, y: @y, z: @z)
+      res = self
+      trans.each do |t|
+        res -= Helpers::chamfer(l: t[:length] + 0.02, h: height)
+          .rotate(z: (t[:z_rot] - 180))
+          .rotate(x: t[:x_rot], y: t[:y_rot])
+          .translate(x: t[:x_trans], y: t[:y_trans], z: t[:z_trans])
+      end
+      res
+    end
+
+    def get_point_on(args = {})
+      args[:x] = @x
+      args[:y] = @y
+      args[:z] = @z
+      args[:centered] = @centered
+      args[:centered_z] = @centered
+      args[:transformations] = @transformations
+      calculate_point_on(args)
+    end
+
+    def fillet(args = {})
+      faces = normalise_edges(args)
+      radius = args[:r] || args[:radiusg]
+      trans = translations_for_edge(onto: self, faces: faces, x: @x, y: @y, z: @z, tolerance: 0)
+      res = self
+      trans.each do |t|
+        res -= Helpers::fillet(h: t[:length], r: radius)
+          .rotate(z: t[:z_rot])
+          .rotate(x: t[:x_rot], y: t[:y_rot])
+          .translate(x: t[:x_trans], y: t[:y_trans], z: t[:z_trans])
+      end
+      res
+    end
+
+    def to_rubyscad
+      args = { size: [@x, @y, @z] }
+      args[:center] = @centered if @centered
+      RubyScadBridge.new.cube(args)
+    end
+  end
+
+  def cube(args = {}, y = nil, z = nil)
+    if args.is_a? Numeric
+      args = {x: args}
+      args[:y] = y if y
+      args[:z] = z if z
+    end
+    Cube.new(args)
+  end
+end

data/lib/solidruby/primitives/cylinder.rb

@@ -0,0 +1,72 @@
+#    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::Primitives
+  class Cylinder < Primitive
+    alias_attr :h, :height
+    alias_attr :r, :radius
+
+    def initialize(args={})
+      d = args[:diameter] || args[:d]
+      d /= 2.0 unless d.nil?
+      @r = args[:radius] || args[:r] || d
+      @h = args[:height] || args[:h]
+      super(args)
+    end
+
+    def to_rubyscad
+      RubyScadBridge.new.cylinder(@attributes)
+    end
+
+    def get_point_on(args = {})
+      # a cube the same size as the cylinder
+      args[:x] = @r*Math.sqrt(2)
+      args[:y] = @r*Math.sqrt(2)
+      args[:z] = @h
+      args[:centered] = true
+      args[:centered_z] = false
+      args[:transformations] = @transformations
+      calculate_point_on(args)
+    end
+  end
+
+  def cylinder(args)
+    # inner diameter handling
+    if args[:id]
+      id = args.delete(:id)
+      args2 = args.dup
+      args2[:d] = id
+
+      if args[:ih]
+        # if it has an inner height, add a tiny bit to the bottom
+        ih = args.delete(:ih)
+        args2[:h] = ih + 0.01
+      else
+        # otherwise add to both bottom and top to make a clear cut in OpenSCAD
+        args2[:h] += 0.02
+      end
+
+      # if we have a ifn value, change the fn value of the inner cut
+      if args[:ifn]
+        ifn = args.delete(:ifn)
+        args2[:fn] = ifn
+      end
+
+      return cylinder(args) - cylinder(args2).translate(z: -0.01)
+    end
+
+    Cylinder.new(args)
+  end
+end

data/lib/solidruby/primitives/import.rb

@@ -0,0 +1,42 @@
+#    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::Primitives
+  class Import < Primitive
+    alias_attr :file
+    alias_attr :layer
+    alias_attr :center, :ce
+    alias_attr :convexity, :co
+    alias_attr :scale
+
+    def initialize(attributes)
+      if attributes.is_a? String
+        attributes = {file: attributes}
+      end
+      abs_path = attributes.delete(:absolue_path) || false
+
+      super(attributes)
+      @attributes[:file] = File.expand_path(@attributes[:file]) if abs_path
+    end
+
+    def to_rubyscad
+      RubyScadBridge.new.import(@attributes)
+    end
+  end
+
+  def import(args)
+    Import.new(args)
+  end
+end