jenncad 1.0.0.pre.alpha14 → 1.0.0.pre.alpha17

data/lib/jenncad/primitives/cylinder.rb

@@ -1,6 +1,6 @@
 module JennCad::Primitives
-  class Cylinder < Primitive
-    attr_accessor :d, :d1, :d2, :r, :fn
+  class Cylinder < Circle
+    attr_accessor :d, :d1, :d2, :r, :fn, :anchors
     def initialize(args)
       if args.kind_of?(Array) && args[0].kind_of?(Hash)
         args = args.first
@@ -24,6 +24,7 @@ module JennCad::Primitives
         r2: nil,
         z: nil,
         r: 0,
+        cz: false,
         margins: {
           r: 0,
           d: 0,
@@ -31,7 +32,7 @@ module JennCad::Primitives
         },
         fn: nil,
       }.deep_merge!(args)
-
+      init(args)
       # FIXME:
       # - margins calculation needs to go to output
       # - assinging these variables has to stop
@@ -40,7 +41,24 @@ module JennCad::Primitives
       @z = args[:z] || args[:h]
       handle_radius_diameter
       handle_fn
-      super(args)
+      @dimensions = [:x, :y, :z]
+      set_anchors
+    end
+
+    def set_anchors
+      set_anchors_2d
+      # TODO: figure out if we also want to have "corners"
+      # - possibly move it like a cube
+      # - points at 45 ° angles might not be that useful unless you can get the point on the circle at a given angle
+      # - inner/outer points could be useful for small $fn values
+
+      if @opts[:cz]
+        set_anchor :bottom_face, z: -@z/2.0
+        set_anchor :top_face, z: @z/2.0
+      else
+        set_anchor :bottom_face, z: 0
+        set_anchor :top_face, z: @z
+      end
     end
 
     def openscad_params
@@ -60,51 +78,19 @@ module JennCad::Primitives
     # Centers the cylinder around it's center point by height
     # This will transform the cylinder around the center point.
     def cz
+      @opts[:cz] = true
+      @transformations ||= []
       @transformations << Move.new(z: -@z / 2.0)
+      set_anchors
       self
     end
 
-    def handle_fn
-      case @opts[:fn]
-        when nil, 0
-          $fn = auto_dn!
-        else
-          @fn = @opts[:fn]
-      end
-    end
-
-    def auto_dn!
-      case @d
-        when (16..)
-          @fn = (@d*4).ceil
-        else
-          @fn = 64
-      end
-    end
-
-    def handle_radius_diameter
-      case @opts[:d]
-      when 0, nil
-        @r = @opts[:r].to_d + @opts[:margins][:r].to_d
-        @d = @r * 2.0
-      else
-        @d = @opts[:d].to_d + @opts[:margins][:d].to_d
-        @r = @d / 2.0
-      end
-
-      case @opts[:d1]
-      when 0, nil
-      else
-        @d1 = @opts[:d1].to_d + @opts[:margins][:d].to_d
-        @d2 = @opts[:d2].to_d + @opts[:margins][:d].to_d
-      end
-
-      case @opts[:r1]
-      when 0, nil
-      else
-        @d1 = 2 * @opts[:r1].to_d + @opts[:margins][:d].to_d
-        @d2 = 2 * @opts[:r2].to_d + @opts[:margins][:d].to_d
-      end
+    def z=(val)
+      @z = val
+      @h = val
+      opts[:h] = val
+      opts[:z] = val
+      set_anchors
     end
 
     def h

data/lib/jenncad/primitives/linear_extrude.rb

@@ -4,7 +4,7 @@ module JennCad::Primitives
     def initialize(part, args={})
       @transformations = []
       @parts = [part]
-      @z = args[:h] || args[:height]
+      @z = args[:h] || args[:height] || args[:z]
       @center_bool = args[:center]
       @convexity = args[:convexity]
       @twist = args[:twist]

data/lib/jenncad/primitives/polygon.rb

@@ -1,9 +1,12 @@
 module JennCad::Primitives
   class Polygon < Primitive
-    attr_accessor :points
+    attr_accessor :points, :paths
     def initialize(args)
-      super
       @points = args[:points]
+      @paths = args[:paths]
+      @convexity = args[:convexity] || 10
+      @dimensions = [:x, :y]
+      super
     end
   end
 end

data/lib/jenncad/primitives/polyhedron.rb

@@ -0,0 +1,35 @@
+module JennCad::Primitives
+  class Polyhedron < Primitive
+    attr_accessor :points, :faces, :convexity
+    def initialize(args)
+      @opts = args
+      @points = args[:points]
+      @faces = args[:faces]
+      @convexity = args[:convexity] || 10
+
+      super
+    end
+
+    def face(i)
+      unless @faces[i]
+        $log.error "polyhedron: Cannot find face #{i}"
+        return self
+      end
+      face = 0
+      poly_faces = []
+      poly_points = []
+      @faces[i].each do |f|
+        point = @points[f]
+        if point.nil?
+          $log.error "polyhedron: Cannot find point #{f} for face #{i}"
+        end
+        poly_points << point
+        poly_faces << face
+        face += 1
+        #poly_points << [point[0], point[1]]
+      end
+      #polygon(points: poly_points)
+      polyhedron(points: poly_points, faces: [poly_faces, poly_faces.reverse])
+    end
+  end
+end

data/lib/jenncad/primitives/primitive.rb

@@ -1,5 +1,7 @@
 module JennCad::Primitives
   class Primitive < JennCad::Thing
+    attr_accessor :dimensions
+
     def initialize(*args)
       super(*args)
     end
@@ -7,7 +9,9 @@ module JennCad::Primitives
     def handle_margins
       @x = @opts[:x].to_d + @opts[:margins][:x].to_d
       @y = @opts[:y].to_d + @opts[:margins][:y].to_d
-      @z = @opts[:z].to_d + @opts[:margins][:z].to_d
+      if @opts[:z]
+        @z = @opts[:z].to_d + @opts[:margins][:z].to_d
+      end
     end
 
     def handle_diameter
@@ -20,5 +24,20 @@ module JennCad::Primitives
       end
     end
 
+    def feed_opts(args)
+      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)
+        @opts.deep_merge!(args)
+      else
+        @opts.deep_merge!(args)
+      end
+    end
+
+
   end
 end

data/lib/jenncad/primitives/rounded_cube.rb

@@ -4,6 +4,7 @@ module JennCad::Primitives
     include JennCad::Features::Cuttable
 
     def initialize(args)
+
       if args.kind_of?(Array) && args[0].kind_of?(Hash)
         args = args.first
       end
@@ -35,20 +36,43 @@ module JennCad::Primitives
           z: 0,
         },
       }.deep_merge!(args)
+      if args.kind_of? Array
+        args.each do |a|
+          feed_opts(parse_xyz_shortcuts(a))
+        end
+      else
+        feed_opts(parse_xyz_shortcuts(args))
+      end
+      init(args)
+
+
       handle_margins
       handle_diameter
-      super(opts)
+      if @opts[:z] && opts[:z].to_d > 0
+        @dimensions = [:x, :y, :z]
+      else
+        @dimensions = [:x, :y]
+      end
+
     end
 
     def to_openscad
-      return cube(@opts) if @d == 0
+      # FIXME: this check needs to be done on object creation
+      #        otherwise it fails to position it
+      if @d == 0
+        if @z.to_d > 0
+          return cube(@opts)
+        else
+          return square(@opts)
+        end
+      end
       # make diameter not bigger than any side
       d = [@d, @x, @y].min
       res = HullObject.new(
-        cylinder(d: d, h:z+z_margin),
-        cylinder(d: d).move(x: @x - d, y: 0),
-        cylinder(d: d).move(x: 0, y: @y - d),
-        cylinder(d: d).move(x: @x - d, y: @y - d),
+        circle(d: d),
+        circle(d: d).move(x: @x - d, y: 0),
+        circle(d: d).move(x: 0, y: @y - d),
+        circle(d: d).move(x: @x - d, y: @y - d),
       )
       res = res.move(xy: d/2.0)
 
@@ -56,6 +80,10 @@ module JennCad::Primitives
         res += apply_flat_edge(edge)
       end
 
+      if @z.to_d > 0
+        res = res.extrude(z: @z + z_margin)
+      end
+
       res = union(res) # put everything we have in a parent union that we can apply the transformations of this object of
       res.transformations = @transformations
 
@@ -64,23 +92,25 @@ module JennCad::Primitives
       res
     end
 
-    def flat(edge)
+    def flat(*edges)
       @opts[:flat_edges] ||= []
-      @opts[:flat_edges] << edge
+      edges.each do |edge|
+        @opts[:flat_edges] << edge
+      end
       self
     end
 
     private
     def apply_flat_edge(edge)
       case edge
-      when :up
-        cube(x: @x, y: @y/2.0, z: @z).nc.moveh(y:@y)
-      when :down
-        cube(x: @x, y: @y/2.0, z: @z).nc
+      when :up, :top
+        square(x: @x, y: @y/2.0).nc.moveh(y:@y)
+      when :down, :bottom
+        square(x: @x, y: @y/2.0).nc
       when :right
-        cube(x: @x/2.0, y: @y, z: @z).nc.moveh(x:@x)
+        square(x: @x/2.0, y: @y).nc.moveh(x:@x)
       when :left
-        cube(x: @x/2.0, y: @y, z: @z).nc
+        square(x: @x/2.0, y: @y).nc
       else
         nil
       end

data/lib/jenncad/primitives/slot.rb

@@ -14,16 +14,21 @@ module JennCad::Primitives
         args = [:d, :z].zip(args.flatten).to_h
         args.deep_merge!(m)
       end
-
-      args[:z] ||= args[:h]
+      args = parse_xyz_shortcuts(args)
+      if args[:z].to_d > 0
+        args[:h] = args[:z]
+      else
+        args[:z] = nil
+      end
 
       @opts = {
         d: 0,
         a: 0,
-        z: nil,
         r: nil,
         x: 0,
         y: 0,
+        z: nil,
+        cz: false,
         margins: {
           r: 0,
           d: 0,
@@ -33,9 +38,13 @@ module JennCad::Primitives
 
       super(opts)
 
-      @d = @opts[:d]
-      @a = @opts[:a]
-      @h = @opts[:h]
+      @d = @opts[:d].to_d
+      @a = @opts[:a].to_d
+      @h = @opts[:h].to_d
+      @z = @h
+      @x = @opts[:x].to_d
+      @y = @opts[:y].to_d
+
       @r = @opts[:r] || nil
       if @r
         @d = @r * 2
@@ -54,7 +63,61 @@ module JennCad::Primitives
 
       # TODO: this needs anchors like cube
       # TODO: color on this needs to apply to hull, not on the cylinders.
+      set_anchors
+    end
+
+    def cz
+      @opts[:cz] = true
+      @transformations << Move.new(z: -@z / 2.0)
+      set_anchors
+      self
+    end
+
+
+    def set_anchors
+      @anchors = {} # reset anchors
+      if @opts[:d]
+        rad = @opts[:d] / 2.0
+      else
+        rad = @opts[:r]
+      end
 
+      if @x > 0
+        set_anchor :left, x: - rad
+        set_anchor :right, x: @x + rad
+      elsif @x < 0
+        set_anchor :left, x: @x - rad
+        set_anchor :right, x: rad
+      else
+        set_anchor :left, x: -rad
+        set_anchor :right, x: rad
+      end
+      if @y > 0
+        set_anchor :bottom, y: - rad
+        set_anchor :top, y: @y + rad
+      elsif @y < 0
+        set_anchor :bottom, y: @y - rad
+        set_anchor :top, y: rad
+      else
+        set_anchor :bottom, y: -rad
+        set_anchor :top, y: rad
+      end
+
+      set_anchor :center1, xy: 0
+      set_anchor :center2, x: @x, y: @y
+
+      # TODO: figure out if we also want to have "corners"
+      # - possibly move it like a cube
+      # - points at 45 ° angles might not be that useful unless you can get the point on the circle at a given angle
+      # - inner/outer points could be useful for small $fn values
+
+      if @opts[:cz]
+        set_anchor :bottom_face, z: -@z/2.0
+        set_anchor :top_face, z: @z/2.0
+      else
+        set_anchor :bottom_face, z: 0
+        set_anchor :top_face, z: @z
+      end
     end
 
     def to_openscad

data/lib/jenncad/primitives/square.rb

@@ -0,0 +1,181 @@
+module JennCad::Primitives
+  class Square < Primitive
+    attr_accessor :corners, :sides
+
+    def initialize(args)
+      @opts = {
+        x: 0,
+        y: 0,
+        margins: {
+          x: 0,
+          y: 0,
+        },
+        center: true,
+        center_y: false,
+        center_x: false,
+      }
+      if args.kind_of? Array
+        args.each do |a|
+          feed_opts(parse_xyz_shortcuts(a))
+        end
+      else
+        feed_opts(parse_xyz_shortcuts(args))
+      end
+      init(args)
+
+      handle_margins
+      set_anchors
+      @x = args[:x]
+      @y = args[:y]
+      @dimensions = [:x, :y]
+    end
+
+
+    # used for openscad export
+    def size
+      [@x, @y]
+    end
+
+    def set_anchors
+      set_anchors_2d
+    end
+
+    def set_anchors_2d
+      @anchors = {} # this resets anchors
+
+      if @opts[:center] || @opts[:center_x]
+        left = -@opts[:x] / 2.0
+        right = @opts[:x] / 2.0
+        mid_x = 0
+      else
+        left = 0
+        right =  @opts[:x]
+        mid_x = @opts[:x] / 2.0
+      end
+      if @opts[:center] || @opts[:center_y]
+        bottom = -@opts[:y] / 2.0
+        top = @opts[:y] / 2.0
+        mid_y = 0
+      else
+        bottom = 0
+        top = @opts[:y]
+        mid_y = @opts[:y] / 2.0
+      end
+
+      set_anchor :left, x: left, y: mid_y
+      set_anchor :right, x: right, y: mid_y
+      set_anchor :top, x: mid_x, y: top
+      set_anchor :bottom, x: mid_x, y: bottom
+      set_anchor :top_left, x: left, y: top
+      set_anchor :top_right, x: right, y: top
+      set_anchor :bottom_left, x: left, y: bottom
+      set_anchor :bottom_right, x: right, y: bottom
+
+      # we need to re-do the inner ones, if they were defined
+      if @inner_anchor_defs && @inner_anchor_defs.size > 0
+        @inner_anchor_defs.each do |anch|
+         inner_anchors(anch[:dist], anch[:prefix], true)
+        end
+      end
+
+      self
+    end
+
+    def inner_anchors(dist, prefix=:inner_, recreate=false)
+      if dist.nil?
+        $log.error "Distance of nil passed to inner anchors. Please check the variable name you passed along"
+        return self
+      end
+
+      @inner_anchor_defs ||= []
+      @inner_anchor_defs << { "dist": dist, "prefix": prefix } unless recreate
+
+#      $log.info "dist: #{dist}, prefix: #{prefix}"
+      sides = {
+        left: {x: dist, y: 0},
+        right: {x: -dist, y: 0},
+        top: {x: 0, y: -dist},
+        bottom: {x: 0, y: dist},
+      }
+      corners = {
+        top_left: {x: dist, y: -dist},
+        top_right: {x: -dist, y: -dist},
+        bottom_left: {x: dist, y: dist},
+        bottom_right: {x: -dist, y: dist},
+      }
+      new_sides = []
+      new_corners = []
+
+      sides.merge(corners).each do |key, vals|
+        new_dist = anchor(key).dup
+        new_dist[:x] += vals[:x]
+        new_dist[:y] += vals[:y]
+        name = [prefix, key].join.to_sym
+#        $log.info "Set anchor #{name} , new dist #{new_dist}"
+        set_anchor name, new_dist
+        if sides.include? key
+          new_sides << name
+        end
+        if corners.include? key
+          new_corners << name
+        end
+      end
+
+      sides_name = [prefix, "sides"].join
+      corners_name = [prefix, "corners"].join
+      all_name = [prefix, "all"].join
+      self.class.__send__(:attr_accessor, sides_name.to_sym)
+      self.class.__send__(:attr_accessor, corners_name.to_sym)
+      self.class.__send__(:attr_accessor, all_name.to_sym)
+      self.__send__("#{sides_name}=", new_sides)
+      self.__send__("#{corners_name}=", new_corners)
+      self.__send__("#{all_name}=", new_corners+new_sides)
+
+
+      self
+    end
+
+
+
+    def not_centered
+      @opts[:center] = false
+      set_anchors
+      self
+    end
+    alias :nc :not_centered
+
+    def cx
+      nc
+      @opts[:center_x] = true
+      set_anchors
+      self
+    end
+    alias :center_x :cx
+
+    def cy
+      nc
+      @opts[:center_y] = true
+      set_anchors
+      self
+    end
+    alias :center_y :cy
+
+
+
+    def centered_axis
+      return [:x, :y] if @opts[:center]
+      a = []
+      a << :x if @opts[:center_x]
+      a << :y if @opts[:center_y]
+      a << :z if @opts[:center_z]
+      a
+    end
+
+    def to_openscad
+      self.mh(centered_axis.to_h{|a| [a, -@opts[a]] }) # center cube
+    end
+
+
+
+  end
+end

data/lib/jenncad/primitives/subtract_object.rb

@@ -57,35 +57,47 @@ module JennCad::Primitives
       others.each do |part|
         #puts part.inspect
         #puts "#{part.calc_z+part.calc_h} ; #{compare_h}"
+        add_z = nil
         if part.respond_to? :z
           part.opts[:margins] ||= {}
-          if part.referenced_z && part.z != 0.0
+          if part.referenced_z && part.z != 0.0 && part.is_3d?
             case part
-            when JennCad::Circle
             when JennCad::BooleanObject
             else
-              $log.debug part if part.opts[:debug]
+              # $log.debug part if part.opts[:debug]
               part.opts[:margins][:z] ||= 0.0
               unless part.opts[:margins][:z] == 0.2
+                $log.debug "fixing possible z fighting for referenced object: #{part.class} #{part.z} 0.1 down" if part.opts[:debug]
                 part.opts[:margins][:z] = 0.2
                 part.mz(-0.1)
               end
             end
           elsif part.z == compare_h
             $log.debug "fixing possible z fighting: #{part.class} #{part.z}" if part.opts[:debug]
-            part.opts[:margins][:z] += 0.008
-            part.mz(-0.004)
+            add_z = 0.008
+            move_z = -0.004
           elsif part.calc_z == compare_z
 #            puts "z fighting at bottom: #{part.calc_z}"
-            part.opts[:margins][:z] += 0.004
+            add_z = 0.004
            # part.z+=0.004
-            part.mz(-0.002)
+            move_z = -0.002
           elsif part.calc_z.to_d+part.calc_h.to_d == compare_h
 #            puts "z fighting at top: #{compare_h}"
             #part.z+=0.004
-            part.opts[:margins][:z] += 0.004
-            part.mz(0.002)
+            add_z = 0.004
+            move_z = 0.002
           end
+
+          if add_z && part.is_3d?
+            if part.kind_of? Part
+              part.modify_values(part, {z: add_z}, {mode: :add})
+            end
+            part.opts[:margins][:z] += add_z
+            part.mz(move_z)
+          end
+
+
+
         end
       end
     end

data/lib/jenncad/primitives.rb

@@ -1,10 +1,12 @@
 require "jenncad/primitives/primitive"
 require "jenncad/primitives/circle"
+require "jenncad/primitives/square"
 require "jenncad/primitives/cylinder"
 require "jenncad/primitives/sphere"
 require "jenncad/primitives/cube"
 require "jenncad/primitives/rounded_cube"
 require "jenncad/primitives/polygon"
+require "jenncad/primitives/polyhedron"
 require "jenncad/primitives/slot"
 require "jenncad/primitives/boolean_object"
 require "jenncad/primitives/union_object"