jenncad 1.0.0.pre.alpha15 → 1.0.0.pre.alpha18

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,42 @@ 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
+      set_anchors
     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 +79,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 +91,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"

data/lib/jenncad/shortcuts.rb

@@ -3,6 +3,11 @@ module JennCad
     Circle.new(args).set_parent(self)
   end
 
+  def square(args)
+    Square.new(args).set_parent(self)
+  end
+  alias :sq :square
+
   def cylinder(*args)
     Cylinder.new(args).set_parent(self)
   end
@@ -18,6 +23,10 @@ module JennCad
     Polygon.new(args).set_parent(self)
   end
 
+  def polyhedron(args)
+    Polyhedron.new(args).set_parent(self)
+  end
+
   def slot(*args)
     Slot.new(args).set_parent(self)
   end
@@ -32,6 +41,7 @@ module JennCad
   end
   alias :rcube :rounded_cube
   alias :rc :rounded_cube
+  alias :rsq :rounded_cube
 
   # import/use OpenScad library
   def import(import,name,args)

data/lib/jenncad/thing.rb

@@ -11,6 +11,10 @@ module JennCad
     attr_accessor :parent
 
     def initialize(args={})
+      init(args)
+    end
+
+    def init(args={})
       @transformations = []
       # calculated origin; only works for move atm
       @calc_x = 0
@@ -18,7 +22,7 @@ module JennCad
       @calc_z = 0
       @calc_h = args[:z] || 0
       @anchors = {}
-      @parent = args[:parent]
+      @parent = args[:parent] || nil
       @opts ||= args
       @cache = nil
     end
@@ -35,12 +39,70 @@ module JennCad
 
     def set_flag(key)
       set_option(key, true)
+      self
     end
 
     def unset_flag(key)
       set_option(key, false)
+      self
+    end
+
+
+    def cut_to(face, part=nil, args={})
+      an = anchor(face, part)
+      unless an
+        $log.error "Cannot find anchor to cut_to"
+        return self
+      end
+      if an[:z].to_d == 0.0
+        $log.error "cut_to only supports cuts to an anchor with Z set. This anchor: #{an}"
+        return self
+      end
+      modify_values(self, z: an[:z].to_d)
+      self.name="#{self.class}_cut_to_#{an[:z].to_f}"
+      self
+    end
+
+    def modify_values(parts, value, opts = {})
+      case parts
+       when Array
+          parts.each do |pa|
+            modify_values(pa, value, opts)
+          end
+        else
+          if parts.kind_of?(BooleanObject)
+            modify_values(parts.only_additives_of(parts), value, opts)
+          elsif parts.kind_of?(Part)
+            modify_values(parts.part, value, opts)
+            modify_values(parts.get_contents, value, opts)
+            parts.modify_values!(value, opts)
+          elsif parts.kind_of?(Primitive)
+            parts.modify_values!(value, opts)
+          end
+      end
+    end
+
+    def modify_values!(values, opts)
+      $log.info "Modify value! #{self.class} #{values}" if self.debug?
+      values.each do |key, val|
+        if @opts
+          case opts[:mode]
+            when :add
+              @opts[key] = @opts[key].to_d + val.to_d
+            when :sub
+              @opts[key] = @opts[key].to_d - val.to_d
+            else
+              @opts[key] = val
+          end
+        end
+        if self.respond_to? key
+          self.send("#{key}=", @opts[key])
+        end
+      end
+      $log.info "Modified value now: #{self.inspect}" if self.debug?
     end
 
+
     def debug?
       option(:debug) || false
     end
@@ -55,20 +117,22 @@ module JennCad
       self
     end
 
-    def anchor(name, thing=nil)
+    def anchor(name, thing=nil, args={})
       if thing
-        res = thing.anchor(name)
+        res = thing.anchor(name, nil, args)
         return res unless res.nil?
       end
       @anchors ||= {}
       if anch = @anchors[name]
         return anch
+      elsif args[:fail_quick] && args[:fail_quick] == true
+        return
       elsif @parent
         return @parent.anchor(name)
       elsif self.respond_to? :get_contents
         con = get_contents
         if con.respond_to? :anchor
-          con.anchor(name)
+          con.anchor(name, nil, fail_quick: true)
         end
       end
     end
@@ -82,9 +146,19 @@ module JennCad
     alias :sa :set_anchor
 
     def set_anchor_from(name, new_name, args={})
-      a = anchor(name).dup
+      unless name.kind_of? Symbol or name.kind_of? String
+        $log.error "set_anchor_from: name must be a string or symbol. Supplied: #{name}"
+        return
+      end
+      unless new_name.kind_of? Symbol or new_name.kind_of? String
+        $log.error "set_anchor_from: new_name must be a string or symbol. Supplied: #{new_name}"
+        return
+      end
+
+
+      a = anchor(name, args[:from]).dup
       if !a
-        log.error "set_anchor_from couldn't find anchor #{name}"
+        $log.error "set_anchor_from couldn't find anchor #{name}"
         return
       end
 
@@ -213,6 +287,27 @@ module JennCad
      return args
     end
 
+    # reset last move
+    def reset_last_move
+      lt = @transformations.last
+      unless lt.class == Move
+        $log.error "Tried to call rst_move but last object is a #{lt.class}"
+        return self
+      end
+      @transformations.delete_at(-1)
+
+      self
+    end
+    alias :rstlm :reset_last_move
+
+    # resets all transformations
+    def reset
+      @transformations = []
+      self
+    end
+    alias :rst :reset
+
+
     def move(args={})
       return self if args.nil? or args.empty?
 
@@ -275,7 +370,7 @@ module JennCad
         thing = nil
       end
 
-      an = anchor(key, thing)
+      an = anchor(key, thing, args)
 
       unless an
         $log.error "Error: Anchor #{key} not found"
@@ -293,6 +388,7 @@ module JennCad
         end
       end
     end
+    alias :ma :movea
 
     # move to anchor - inverted
     def moveai(key, thing=nil, args={})
@@ -303,7 +399,7 @@ module JennCad
       args[:inverted] = true
       movea(key, thing, args)
     end
-
+    alias :mai :moveai
 
     # move half
     def moveh(args={})
@@ -549,7 +645,7 @@ module JennCad
       return @parts unless @parts.nil?
 
       if @cache
-        return @cache
+        return @cache unless option(:no_cache) == true
       end
 
       if self.respond_to? :part
@@ -661,5 +757,25 @@ module JennCad
       end
     end
 
+    def to_mod(name)
+      a = Aggregation.new(name, self)
+      a.transformations = @transformations
+      a
+    end
+
+    def is_2d?
+      !is_3d?
+    end
+
+    def is_3d?
+      if self.respond_to?(:dimensions) && self.dimensions
+        return true if self.dimensions && self.dimensions.include?(:z)
+      else
+        # assume true if not set
+        return true
+      end
+      false
+    end
+
   end
 end