jenncad 1.0.0.pre.alpha13 → 1.0.0.pre.alpha16

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

@@ -5,14 +5,14 @@ module JennCad::Primitives
     end
 
     def handle_margins
-      @x = @opts[:x] + @opts[:margins][:x]
-      @y = @opts[:y] + @opts[:margins][:y]
-      @z = @opts[:z] + @opts[:margins][:z]
+      @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
     end
 
     def handle_diameter
-      @d = opts[:d]
-      @r = opts[:r]
+      @d = opts[:d].to_d
+      @r = opts[:r].to_d
       if @d
         @r = @d/2.0
       elsif @r

data/lib/jenncad/primitives/rounded_cube.rb

@@ -64,18 +64,20 @@ 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
+      when :up, :top
         cube(x: @x, y: @y/2.0, z: @z).nc.moveh(y:@y)
-      when :down
+      when :down, :bottom
         cube(x: @x, y: @y/2.0, z: @z).nc
       when :right
         cube(x: @x/2.0, y: @y, z: @z).nc.moveh(x:@x)

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
@@ -79,16 +142,16 @@ module JennCad::Primitives
     end
 
     def end_vector
-      if @a.to_f == 0.0
+      if @a.to_d == 0.0
         return [@len_x, 0] if @len_x
         return [0, @len_y] if @len_y
       end
       if @len_x
-        x = cos(PI*@a/180.0)*@len_x.to_f
-        y = sin(PI*@a/180.0)*@len_x.to_f
+        x = cos(PI*@a/180.0)*@len_x.to_d
+        y = sin(PI*@a/180.0)*@len_x.to_d
       else
-        x = -1* sin(PI*@a/180.0)*@len_y.to_f
-        y = cos(PI*@a/180.0)*@len_y.to_f
+        x = -1* sin(PI*@a/180.0)*@len_y.to_d
+        y = cos(PI*@a/180.0)*@len_y.to_d
       end
       [x,y]
     end

data/lib/jenncad/primitives/subtract_object.rb

@@ -2,13 +2,13 @@ module JennCad::Primitives
   class SubtractObject < BooleanObject
     def inherit_z
       @z = 0
-      @calc_z = parts.first.calc_z.to_f
+      @calc_z = parts.first.calc_z.to_d
 
       only_additives_of(@parts).each do |p|
         if option(:debug)
           $log.debug "inherit_z checks for: #{p}"
         end
-        z = p.z.to_f
+        z = p.z.to_d
         @z = z if z > @z
       end
       $log.debug "inherit_z called, biggest z found: #{@z}" if option(:debug)
@@ -57,6 +57,7 @@ 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
@@ -64,28 +65,40 @@ module JennCad::Primitives
             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)
-          elsif part.calc_z.to_f+part.calc_h.to_f == compare_h
+            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
+            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

@@ -5,6 +5,7 @@ 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

@@ -18,6 +18,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
@@ -93,8 +97,8 @@ module JennCad
   private
   def boolean_operation(part, klass)
     if part.respond_to? :transformations
-      # Since ruby doesn't provide a way to make a deep clone, this seems to be the simplest solution that will effectively do that:
-      part = Marshal.load(Marshal.dump(part))
+      # Clone the part in place
+      part = part.fix
     end
 
     case self
@@ -103,7 +107,12 @@ module JennCad
     when klass
       add_or_new(part)
     else
-      klass.new(self,part)
+      own_part = if self.respond_to? :transformations
+        self.fix # clone self
+      else
+        self
+      end
+      klass.new(own_part,part)
     end
   end
 end

data/lib/jenncad/thing.rb

@@ -33,25 +33,102 @@ module JennCad
       @opts[key] = val
     end
 
+    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
+
+    def fixate
+      Marshal.load(Marshal.dump(self))
+    end
+    alias :fix :fixate
+
     def set_parent(parent)
       @parent = parent
       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
@@ -64,6 +141,32 @@ module JennCad
     end
     alias :sa :set_anchor
 
+    def set_anchor_from(name, new_name, args={})
+      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}"
+        return
+      end
+
+      [:x, :y, :z, :xy, :xz, :xyz, :yz].each do |key|
+        a[key] ||= 0.to_d
+        args[key] ||= 0.to_d
+        a[key] += args[key]
+      end
+      set_anchor new_name, a
+    end
+    alias :saf :set_anchor_from
+
     def auto_extrude
       ret = self.extrude
       ret.set_option(:auto_extrude, true)
@@ -93,7 +196,7 @@ module JennCad
       case self
       when UnionObject
         ref = self.parts.first
-        rz = self.z.to_f + self.calc_h.to_f
+        rz = self.z.to_d + self.calc_h.to_d
       when BooleanObject
         ref = self.parts.first
         rz = ref.calc_z + ref.calc_h
@@ -121,7 +224,7 @@ module JennCad
     alias :fy :flip_y
 
     def radians(a)
-      a.to_f/180.0*PI
+      a.to_d/180.0*PI
     end
 
     # experiment
@@ -180,22 +283,65 @@ 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?
+
       if args.kind_of? Array
         x,y,z = args
         return move(x:x, y:y, z:z)
       end
       args = parse_xyz_shortcuts(args)
 
+      if args[:x].to_d == 0.0 && args[:y].to_d == 0.0 && args[:z].to_d == 0.0
+        return self
+      end
+
       @transformations ||= []
       if args[:prepend]
         @transformations.prepend(Move.new(args))
       else
-        @transformations << Move.new(args)
+        lt = @transformations.last
+
+        chain = if args[:chain]
+          args[:chain]
+        else
+          $jenncad_profile.chain_moves
+        end
+
+        if lt && lt.class == Move && chain == false
+          $log.debug "#{self} at move: Adding to previous move #{lt.inspect} , args: #{args}" if self.debug?
+          lt.x += args[:x].to_d
+          lt.y += args[:y].to_d
+          lt.z += args[:z].to_d
+        else
+          $log.debug "#{self} at move: Adding move of #{args} to transformations" if self.debug?
+          @transformations << Move.new(args)
+        end
       end
-      @calc_x += args[:x].to_f
-      @calc_y += args[:y].to_f
-      @calc_z += args[:z].to_f
+      @calc_x += args[:x].to_d
+      @calc_y += args[:y].to_d
+      @calc_z += args[:z].to_d
       self
     end
     alias :translate :move
@@ -214,30 +360,42 @@ module JennCad
     end
 
     # move to anchor
-    def movea(key, thing=nil)
-      an = anchor(key, thing)
+    def movea(key, thing=nil, args={})
+      if thing.kind_of? Hash # if you leave out thing, args may be interpreted as thing
+        args = thing
+        thing = nil
+      end
+
+      an = anchor(key, thing, args)
 
       unless an
         $log.error "Error: Anchor #{key} not found"
         $log.error "Available anchors: #{@anchors}"
         return self
       else
-        self.move(an.dup)
+        m = an.dup
+        if args[:chain]
+          m[:chain] = args[:chain]
+        end
+        if args[:inverted]
+          self.movei(m)
+        else
+          self.move(m)
+        end
       end
     end
+    alias :ma :movea
 
     # move to anchor - inverted
-    def moveai(key, thing=nil)
-      an = anchor(key, thing)
-      unless an
-        $log.error "Error: Anchor #{key} not found"
-        $log.error "Available anchors: #{@anchors}"
-        return self
-      else
-        self.movei(an.dup)
+    def moveai(key, thing=nil, args={})
+      if thing.kind_of? Hash # if you leave out thing, args may be interpreted as thing
+        args = thing
+        thing = nil
       end
+      args[:inverted] = true
+      movea(key, thing, args)
     end
-
+    alias :mai :moveai
 
     # move half
     def moveh(args={})
@@ -272,6 +430,7 @@ module JennCad
           to[key] = args[key]*-1
         end
       end
+      to[:chain] = args[:chain]
       move(to)
     end
 
@@ -335,7 +494,7 @@ module JennCad
     end
 
     def top_of(other_object)
-      self.move(z:other_object.z+other_object.calc_z.to_f)
+      self.move(z:other_object.z+other_object.calc_z.to_d)
     end
 
     def on_top_of(other_object)
@@ -456,6 +615,8 @@ module JennCad
         return "##{args}"
       when String
         return args
+      when Symbol
+        return args.to_s
       end
       nil
     end
@@ -480,7 +641,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
@@ -564,7 +725,7 @@ module JennCad
     end
 
     def referenced_z
-     return false if @z.to_f != 0.0
+     return false if @z.to_d != 0.0
      return option(:zref) if option(:zref)
      return false
     end
@@ -579,7 +740,7 @@ module JennCad
       when nil, false
         @z + z_margin
       else
-        ref.z.to_f + ref.z_margin.to_f
+        ref.z.to_d + ref.z_margin.to_d
       end
     end
 
@@ -588,9 +749,16 @@ module JennCad
       when nil, {}
         0.0
       else
-        m[:z].to_f
+        m[:z].to_d
       end
     end
 
+
+    def to_mod(name)
+      a = Aggregation.new(name, self)
+      a.transformations = @transformations
+      a
+    end
+
   end
 end

data/lib/jenncad/transformation/color.rb

@@ -16,7 +16,7 @@ module JennCad
 
     def self.check_color_array(a)
       if a.max > 1.0
-        a.map{|l| l.to_f/255.0}
+        a.map{|l| l.to_d/255.0}
       else
         a
       end

data/lib/jenncad/version.rb

@@ -1,3 +1,3 @@
 module JennCad
-  VERSION = "1.0.0-alpha13"
+  VERSION = "1.0.0-alpha16"
 end

data/lib/jenncad.rb

@@ -1,11 +1,11 @@
 require "logger"
 $log = Logger.new(STDOUT)
 
+require 'bigdecimal/util'
 require "geo3d"
 require "deep_merge"
 require "fileutils"
 require "observr"
-require "hanami/cli"
 require "active_support"
 
 include Math