jenncad 1.0.0.pre.alpha1

data/lib/jenncad/extras/iso7380.rb

@@ -0,0 +1,58 @@
+module JennCad::Extras
+  class Iso7380 < Hardware
+    attr_accessor :height
+
+		def initialize(size,length,args={})
+			super(args)
+      @args = args
+			# options for output only:
+			@args[:additional_length] ||= 0
+			@args[:additional_diameter] ||= 0.3
+			@args[:head_margin] ||= 0.0
+
+		#	if @args[:washer] == true
+		#		@washer = Washer.new(size,{:material => @args[:material], :surface => @args[:surface]})
+		#	end
+
+			@size = size
+			@length = length
+			@transformations ||= []
+		end
+
+		def cut
+      res = bolt_7380(@args[:additional_length], @args[:additional_diameter], @args[:head_margin])
+	    Aggregation.new("iso7380c#{@size}#{option_string}", res)
+    end
+
+		def show
+			res = bolt_7380(0,0)
+			#if @washer
+			#	res += @washer.show
+		#		res = res.move(z:-@washer.height)
+	#		end
+			res.color("DarkGray")
+		  Aggregation.new("iso7380s#{@size}#{option_string}", res)
+    end
+
+    # ISO 7380
+  	def bolt_7380(additional_length=0, addtional_diameter=0, head_margin=0)
+	    if head_margin.to_f != 0
+				puts "[warning] :head_margin is not implemented for 7380 bolts"
+			end
+			chart_iso7380 = {
+	                    3 => {head_dia:5.7,head_length:1.65},
+	                    4 => {head_dia:7.6,head_length:2.2},
+	                    5 => {head_dia:9.5,head_length:2.75},
+	                    6 => {head_dia:10.5,head_length:3.3},
+	                    8 => {head_dia:14,head_length:4.4},
+	                    10=> {head_dia:17.5,head_length:5.5},
+	                    12=> {head_dia:21,head_length:6.6},
+
+
+	    }
+	  	res = cylinder(d1:chart_iso7380[@size][:head_dia]/2.0,d2:chart_iso7380[@size][:head_dia],h:chart_iso7380[@size][:head_length]).move(z:-chart_iso7380[@size][:head_length])
+      total_length = @length + additional_length
+      res+= cylinder(d:@size+addtional_diameter, h:total_length)
+	  end
+  end
+end

data/lib/jenncad/jenncad.rb

@@ -0,0 +1,3 @@
+module JennCad
+  include Primitives
+end

data/lib/jenncad/openscad.rb

@@ -0,0 +1,274 @@
+module JennCad
+
+  class OpenScad
+    def initialize(part, fn=64)
+      @imports = []
+      @modules = {}
+      part = part.make_openscad_compatible
+      @main = root(part, "$fn=#{fn};\n")
+
+      @export = ""
+      @imports.uniq.each do |val|
+        @export += "use <#{val}.scad>\n"
+      end
+      @modules.each do |key, val|
+        @export += val
+      end
+      @export += @main
+    end
+
+    def save(file)
+      File.open(file,"w") do |f|
+        f.puts @export
+      end
+    end
+
+    def root(part, head="", tabindex=0)
+      res = head
+
+      res += transform(part) do
+        parse(part, tabindex)
+      end
+      res
+    end
+
+    def transform(part, &block)
+      res += handle_color(part)
+      if part.transformations
+        part.transformations.reverse.each do |trans|
+          res += transformation(trans)
+        end
+      end
+      res += block.yield
+    end
+
+    def print_tree(part, level=0)
+      arr = []
+      arr << parse(part) unless level == 0
+      if part.respond_to?(:parts)
+        part.parts.each do |p|
+          arr << print_tree(p,level+1)
+        end
+      end
+      arr
+    end
+
+
+    def parse(part, tabindex=0)
+      case part
+      when JennCad::OpenScadImport
+        handle_import(part)
+      when JennCad::Aggregation
+        handle_aggregation(part)
+      when JennCad::UnionObject
+        cmd('union', nil, part.parts, tabindex)
+      when JennCad::SubtractObject
+        part.analyze_z_fighting
+        cmd('difference', nil, part.parts, tabindex)
+      when JennCad::IntersectionObject
+        cmd('intersection', nil, part.parts, tabindex)
+      when JennCad::HullObject
+        cmd('hull', nil, part.parts, tabindex)
+      when JennCad::Primitives::Circle
+        cmd('circle', collect_params(part), nil, tabindex)
+      when JennCad::Primitives::Cylinder
+        cmd('cylinder', collect_params(part), nil, tabindex)
+      when JennCad::Primitives::Sphere
+        cmd('sphere', collect_params(part), nil, tabindex)
+      when JennCad::Primitives::Cube
+        handle_cube(part, tabindex)
+      when JennCad::Primitives::LinearExtrude
+        cmd('linear_extrude', part.openscad_params, part.parts, tabindex)
+      when JennCad::Primitives::RotateExtrude
+        cmd('rotate_extrude', part.openscad_params, part.parts, tabindex)
+      when JennCad::Primitives::Projection
+        cmd('projection', collect_params(part), part.parts, tabindex)
+      when JennCad::Primitives::Polygon
+        cmd('polygon', collect_params(part), nil, tabindex)
+      else
+        if part.respond_to?(:parts) && part.parts != nil && !part.parts.empty?
+          res = ""
+          part.parts.each do |p|
+              res += root(p, "", tabindex)
+            end
+          return res
+        elsif part.respond_to?(:part)
+          return root(part.part, "", tabindex)
+        end
+        puts "no idea what to do with #{part.inspect}"
+        return ""
+      end
+    end
+
+    def fmt_params(args)
+      return "" if args == nil
+      if args.kind_of? String
+        return "\"#{args}\""
+      elsif args.kind_of? Array
+        return args.map do |l|
+          if l == nil
+            0
+          elsif l.kind_of? Array
+            l # skipping check of 2-dmin Arrays for now (used in multmatrix)
+          elsif l.to_i == l.to_f
+            l.to_i
+          else
+            l.to_f
+          end
+        end
+      else
+        res = []
+        args.each do |k,v|
+          if k.to_s == "fn"
+            k = "$fn"
+          end
+          if v == nil
+            next
+          end
+          if !v.kind_of?(Array) && !v.kind_of?(TrueClass) && !v.kind_of?(FalseClass) && v == v.to_i
+            v = v.to_i
+          end
+          res << "#{k}=#{v}"
+        end
+        res.join(",")
+      end
+    end
+
+    def cmd(name, args, items, tabindex = 0)
+      items ||= []
+      res = cmd_call(name,args)
+      if items.size > 1
+        res << "\n"
+        res << tabs(tabindex) { "{\n" }
+        items.each do |item|
+          res << tabs(tabindex+1) do
+            transform(item) do
+              parse(item, tabindex+1)
+            end
+          end
+        end
+        res << tabs(tabindex) { "}\n" }
+      elsif items.size == 1
+        item = items.first
+        res << transform(item) do
+          parse(item, tabindex)
+        end
+        res << ";\n"
+      else
+        res << ";\n"
+      end
+      return res
+    end
+
+    def tabs(i, &block)
+      "  " * i + block.yield
+    end
+
+    def handle_import(part, tabindex=0)
+      @imports << part.import
+      return tabs(tabindex){ "#{part.name}(#{fmt_params(part.args)});\n" }
+    end
+
+    def handle_aggregation(part, tabindex=0)
+      register_module(part) unless @modules[part.name]
+      use_module(part.name, tabindex)
+    end
+
+    # check children for color values
+      # if none of the children has a color value, we can apply color to this object and all children
+    # if any of the children (excluding children of the kind of BooleanObject) has a color value (that is different from ours), we will apply a fallback color to all children that do not have a color value themselves.
+
+    def handle_color(part)
+      if part && part.respond_to?(:color) && part.color
+        if part.respond_to?(:parts)
+          if part.children_list(JennCad::Aggregation).map{|l| l.color != nil && l.color != part.color}.include?(true)
+            part.children_list(JennCad::Aggregation).each do |child|
+              if child.color == nil && child.color != part.color && !child.kind_of?(BooleanObject)
+                child.set_option :fallback_color, part.color
+              end
+            end
+            return ""
+          end
+        end
+      end
+      return apply_color(part)
+    end
+
+    def apply_color(part)
+      if part && part.respond_to?(:color_or_fallback)
+        color = part.color_or_fallback
+        return "" if color == nil
+        # Allowing color to be string, OpenScad compatible RGBA values of 0..1 or RGBA values of 0..255
+        if color.kind_of?(Array) && color.map{|l| l.to_f > 1.0 ? true : false}.include?(true)
+          color = color.map{|l| l.to_f/255.0}
+        end
+        return cmd_call("color", color)
+      end
+      return ""
+    end
+
+    def register_module(part)
+      # can only accept aggregation
+      @modules[part.name] = "module #{part.name}(){\n"
+      @modules[part.name] += root(part.part)
+      @modules[part.name] += "}\n"
+    end
+
+    def use_module(name, tabindex)
+      tabs(tabindex){ cmd_call(name, nil).to_s+";" }
+    end
+
+    def cmd_call(name, args)
+      args = fmt_params(args)
+      return "#{name}(#{args})"
+    end
+
+    def collect_params(part)
+      res = {}
+      [:d, :r, :h, :r1, :r2, :d1, :d2, :size, :fn, :points].each do |var|
+        if part.respond_to? var
+          res[var] = part.send var
+        end
+      end
+      res
+    end
+
+    def transformation(trans)
+      case trans
+      when JennCad::Move
+        cmd_call("translate",trans.coordinates)
+      when JennCad::Rotate
+        cmd_call("rotate",trans.coordinates)
+      when JennCad::Mirror
+        cmd_call("mirror",trans.coordinates)
+      when JennCad::Multmatrix
+        cmd_call("multmatrix",trans.m)
+      else
+        puts "[openscad exporter] Unkown transformation #{trans.class}"
+        ""
+      end
+    end
+
+    # cubes are now centered in xy by default in jenncad
+    # TODO: should this not be to_openscad in Cube?
+    def handle_cube(part, tabindex)
+      res = ""
+      if part.option(:center)
+        res += transformation(Move.new(x: -part.x/2.0, y: -part.y/2.0))
+      else
+        if part.option(:center_x)
+          res += transformation(Move.new(x: -part.x/2.0))
+        end
+        if part.option(:center_y)
+          res += transformation(Move.new(y: -part.y/2.0))
+        end
+        if part.option(:center_z)
+          res += transformation(Move.new(z: -part.z/2.0))
+        end
+      end
+
+      res += cmd('cube', collect_params(part), nil)
+    end
+
+  end
+end

data/lib/jenncad/part.rb

@@ -0,0 +1,14 @@
+module JennCad
+  # Part should be inherited from the user when making parts
+  class Part < Thing
+
+    def make_openscad_compatible
+      auto_color
+      a = Aggregation.new(self.class.to_s, make_openscad_compatible!(self.part))
+      a.transformations = @transformations
+      a.color(color)
+      a
+    end
+
+  end
+end

data/lib/jenncad/patches/array.rb

@@ -0,0 +1,29 @@
+class Array
+  # Assembles things on top of each other
+  def assemble(partlib=nil, skip_z=false, z=0)
+    map do |part|
+      case part
+      when Array
+        res = part.assemble(partlib, true)
+      when String, Symbol
+        res = partlib[part].yield
+      when Proc
+        res = part.yield
+      else
+        res = part
+      end
+      # FIXME: I added 0.01 to all for now to fix z-fighting issues; this should not be hardcoded like this
+      res, z = res.move(z:z), z + res.z.to_f + 0.01 unless skip_z
+      res
+    end
+    .union
+  end
+
+  def union(&block)
+    if block
+      UnionObject.new(block.yield)
+    else
+      UnionObject.new(self)
+    end
+  end
+end

data/lib/jenncad/primitives/aggregation.rb

@@ -0,0 +1,12 @@
+module JennCad::Primitives
+  class Aggregation < Primitive
+    attr_accessor :part
+
+    def initialize(name=nil, part=nil)
+      super({})
+      @name = name
+      @part = part
+    end
+
+  end
+end

data/lib/jenncad/primitives/boolean_object.rb

@@ -0,0 +1,76 @@
+module JennCad::Primitives
+  class BooleanObject < Primitive
+    def initialize(*parts)
+      @transformations = []
+      if parts.first.kind_of? Array
+        @parts = parts.first
+      else
+        @parts = parts
+      end
+      after_add
+    end
+
+    def add(part)
+      @parts << part
+      after_add
+    end
+
+    def after_add
+      @parts.flatten!
+      @parts.compact!
+      inherit_z
+      inherit_zref
+    end
+
+    def inherit_z
+      heights = @parts.map{|l| l.calc_z.to_f}.uniq
+      if heights.size > 1
+        total_heights = []
+        @parts.each do |p|
+          total_heights << p.z.to_f + p.calc_z.to_f
+        end
+        @z = total_heights.max
+        @calc_z = heights.min
+      else
+        @calc_z = heights.first.to_f
+        @z = @parts.map(&:z).compact.max
+      end
+    end
+
+    def inherit_zref
+      return if @parts.first == nil
+      return if @parts.first.z.to_f == 0.0
+      get_primitives(@parts[1..-1]).flatten.each do |part|
+        if part.z.to_f == 0.0
+          part.set_option :zref, @parts.first
+        end
+      end
+    end
+
+    def get_primitives(obj)
+      res = []
+      if obj.kind_of? Array
+        obj.each do |part|
+          res << part.children_list
+        end
+      else
+        res << obj.children_list
+      end
+      res
+    end
+
+    def only_additives_of(obj)
+      res = []
+      case obj
+      when Array
+        res << obj.map{|l| only_additives_of(l)}
+      when SubtractObject
+      when IntersectionObject
+      else
+        res << obj
+      end
+      res.flatten
+    end
+
+  end
+end

data/lib/jenncad/primitives/circle.rb

@@ -0,0 +1,11 @@
+module JennCad::Primitives
+  class Circle < Primitive
+    attr_accessor :d, :r, :fn
+    def initialize(args)
+      super
+      @d = args[:d]
+      @r = args[:r]
+      @fn = args[:fn]
+    end
+  end
+end

data/lib/jenncad/primitives/cube.rb

@@ -0,0 +1,69 @@
+module JennCad::Primitives
+  class Cube < Primitive
+    attr_accessor :x,:y,:z
+
+    def initialize(args)
+      if args.kind_of?(Array) && args[0].kind_of?(Hash)
+        args = args.first
+      end
+      if args.kind_of? Array
+        m = {}
+        if args.last.kind_of? Hash
+          m = args.last
+        end
+        args = [:x, :y, :z].zip(args.flatten).to_h
+        args.deep_merge!(m)
+      end
+      @opts = {
+        x: 0,
+        y: 0,
+        z: 0,
+        margins: {
+          x: 0,
+          y: 0,
+          z: 0,
+        },
+        center: true,
+        center_y: false,
+        center_x: false,
+        center_z: false,
+      }.deep_merge!(args)
+      handle_margins
+
+      super(args)
+      @h = @z.dup
+      @calc_h = @z.dup
+    end
+
+    # used for openscad export
+    def size
+      [@x, @y, @z]
+    end
+
+    def center_xy
+      set_option :center, true
+      self
+    end
+
+    def center_x
+      set_option :center_x, true
+      self
+    end
+
+    def center_y
+      set_option :center_y, true
+      self
+    end
+
+    def center_z
+      set_option :center_z, true
+      self
+    end
+
+#    def center
+#      @transformations << Move.new({x:-@x/2,y:-@y/2,z:-@z/2})
+#      self
+#    end
+
+  end
+end

data/lib/jenncad/primitives/cylinder.rb

@@ -0,0 +1,52 @@
+module JennCad::Primitives
+  class Cylinder < Primitive
+    attr_accessor :d, :r, :fn
+    def initialize(args)
+      if args.kind_of?(Array) && args[0].kind_of?(Hash)
+        args = args.first
+      end
+      if args.kind_of? Array
+        m = {}
+        if args.last.kind_of? Hash
+          m = args.last
+        end
+        args = [:d, :z].zip(args.flatten).to_h
+        args.deep_merge!(m)
+      end
+
+      args[:z] ||= args[:h]
+
+      @opts = {
+        d: 0,
+        z: nil,
+        r: 0,
+        margins: {
+          r: 0,
+          d: 0,
+          z: 0,
+        },
+        fn: nil,
+      }.deep_merge!(args)
+
+      # FIXME:
+      # - margins calculation needs to go to output
+      # - assinging these variables has to stop
+      # - r/d need to be automatically calculated by each other
+      # - r+z margin not implemented atm
+      # - need to migrate classes to provide all possible outputs (and non-conflicting ones) to openscad exporter
+      @d = args[:d] + @opts[:margins][:d]
+      @z = args[:z] || args[:h]
+      @r = args[:r]
+      @fn = args[:fn]
+      if @fn == nil && @d > 16
+        @fn = (@d*4).ceil
+      end
+      super(args)
+    end
+
+    def h
+      z
+    end
+
+  end
+end

data/lib/jenncad/primitives/hull_object.rb

@@ -0,0 +1,4 @@
+module JennCad::Primitives
+  class HullObject < BooleanObject
+  end
+end

data/lib/jenncad/primitives/intersection_object.rb

@@ -0,0 +1,4 @@
+module JennCad::Primitives
+  class IntersectionObject < BooleanObject
+  end
+end

data/lib/jenncad/primitives/linear_extrude.rb

@@ -0,0 +1,25 @@
+module JennCad::Primitives
+  attr_accessor :center_bool, :convexity, :twist, :slices, :height
+  class LinearExtrude < JennCad::Thing
+    def initialize(part, args)
+      @transformations = []
+      @parts = [part]
+      @height = args[:h] || args[:height]
+      @center_bool = args[:center]
+      @convexity = args[:convexity]
+      @twist = args[:twist]
+      @slices = args[:slices]
+      @fn = args[:fn]
+    end
+
+    def openscad_params
+      res = {}
+      [:height, :convexity, :twist, :slices, :fn].each do |n|
+        res[n] = self.send n
+      end
+      res[:center] = @center_bool
+      res
+    end
+  end
+
+end

data/lib/jenncad/primitives/openscad_include.rb

@@ -0,0 +1,11 @@
+module JennCad::Primitives
+  class OpenScadImport < Aggregation
+    attr_accessor :import, :args
+
+    def initialize(import, name, args)
+      @import = import
+      @name = name
+      @args = args
+    end
+  end
+end

data/lib/jenncad/primitives/polygon.rb

@@ -0,0 +1,9 @@
+module JennCad::Primitives
+  class Polygon < Primitive
+    attr_accessor :points
+    def initialize(args)
+      super
+      @points = args[:points]
+    end
+  end
+end

data/lib/jenncad/primitives/primitive.rb

@@ -0,0 +1,24 @@
+module JennCad::Primitives
+  class Primitive < JennCad::Thing
+    def initialize(*args)
+      super(*args)
+    end
+
+    def handle_margins
+      @x = @opts[:x] + @opts[:margins][:x]
+      @y = @opts[:y] + @opts[:margins][:y]
+      @z = @opts[:z] + @opts[:margins][:z]
+    end
+
+    def handle_diameter
+      @d = opts[:d]
+      @r = opts[:r]
+      if @d
+        @r = @d/2.0
+      elsif @r
+        @d = @r*2
+      end
+    end
+
+  end
+end

data/lib/jenncad/primitives/projection.rb

@@ -0,0 +1,9 @@
+module JennCad::Primitives
+  class Projection < JennCad::Thing
+    def initialize(part, args)
+      @transformations = []
+      @cut = args[:cut]
+      @parts = [part]
+    end
+  end
+end