jenncad 1.0.0.pre.alpha1 → 1.0.0.pre.alpha4

data/lib/jenncad/primitives/cube.rb

@@ -1,6 +1,6 @@
 module JennCad::Primitives
   class Cube < Primitive
-    attr_accessor :x,:y,:z
+    extend JennCad::Features::Cuttable
 
     def initialize(args)
       if args.kind_of?(Array) && args[0].kind_of?(Hash)
@@ -37,33 +37,41 @@ module JennCad::Primitives
 
     # used for openscad export
     def size
-      [@x, @y, @z]
+      [@x, @y, z+z_margin]
     end
 
-    def center_xy
-      set_option :center, true
-      self
+    def not_centered
+      @opts[:center] = false
     end
+    alias :nc :not_centered
 
-    def center_x
-      set_option :center_x, true
-      self
+    def cx
+      nc
+      @opts[:center_x] = true
     end
 
-    def center_y
-      set_option :center_y, true
-      self
+    def cy
+      nc
+      @opts[:center_y] = true
     end
 
-    def center_z
-      set_option :center_z, true
-      self
+    def cz
+      nc
+      @opts[:center_z] = true
     end
 
-#    def center
-#      @transformations << Move.new({x:-@x/2,y:-@y/2,z:-@z/2})
-#      self
-#    end
+    def centered_axis
+      return [:x, :y] if @opts[:center]
+      a = []
+      a << :x if @opts[:center_x]
+      a << :y if @opts[:center_x]
+      a << :z if @opts[:center_x]
+      a
+    end
+
+    def to_openscad
+      self.mh(centered_axis.to_h{|a| [a, -@opts[a]] }) # center cube
+    end
 
   end
 end

data/lib/jenncad/primitives/cylinder.rb

@@ -1,6 +1,6 @@
 module JennCad::Primitives
   class Cylinder < Primitive
-    attr_accessor :d, :r, :fn
+    attr_accessor :d, :d1, :d2, :r, :fn
     def initialize(args)
       if args.kind_of?(Array) && args[0].kind_of?(Hash)
         args = args.first
@@ -18,6 +18,10 @@ module JennCad::Primitives
 
       @opts = {
         d: 0,
+        d1: nil,
+        d2: nil,
+        r1: nil,
+        r2: nil,
         z: nil,
         r: 0,
         margins: {
@@ -31,21 +35,73 @@ module JennCad::Primitives
       # 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
+      handle_radius_diameter
+      handle_fn
       super(args)
     end
 
+    def openscad_params
+      res = {}
+      if @opts[:d1]
+        [:d1, :d2, :h, :fn].each do |n|
+          res[n] = self.send n
+        end
+      else
+        [:d, :h, :fn].each do |n|
+          res[n] = self.send n
+        end
+      end
+      res
+    end
+
+    def handle_fn
+      case @opts[:fn]
+        when nil, 0
+          $fn = auto_fn!
+        else
+          @fn = @opts[:fn]
+      end
+    end
+
+    def auto_fn!
+      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_f + @opts[:margins][:r].to_f
+        @d = @r * 2.0
+      else
+        @d = @opts[:d].to_f + @opts[:margins][:d].to_f
+        @r = @d / 2.0
+      end
+
+      case @opts[:d1]
+      when 0, nil
+      else
+        @d1 = @opts[:d1].to_f + @opts[:margins][:d].to_f
+        @d2 = @opts[:d2].to_f + @opts[:margins][:d].to_f
+      end
+
+      case @opts[:r1]
+      when 0, nil
+      else
+        @d1 = 2 * @opts[:r1].to_f + @opts[:margins][:d].to_f
+        @d2 = 2 * @opts[:r2].to_f + @opts[:margins][:d].to_f
+      end
+    end
+
     def h
-      z
+      z + z_margin
     end
 
   end

data/lib/jenncad/primitives/rotate_extrude.rb

@@ -1,5 +1,5 @@
 module JennCad::Primitives
-  attr_accessor :convexity
+  attr_accessor :cut, :convexity
   class RotateExtrude < JennCad::Thing
     def initialize(part, args)
       @transformations = []

data/lib/jenncad/primitives/rounded_cube.rb

@@ -1,6 +1,7 @@
 module JennCad::Primitives
   class RoundedCube < Primitive
     attr_accessor :d, :r
+    include JennCad::Features::Cuttable
 
     def initialize(args)
       if args.kind_of?(Array) && args[0].kind_of?(Hash)
@@ -40,21 +41,13 @@ module JennCad::Primitives
       # make diameter not bigger than any side
       @d = [@d, @x, @y].min
       res = HullObject.new(
-        cylinder(d:@d, h:@z).moveh(x: -@x + @d, y: @y - @d),
+        cylinder(d:@d, h:z+z_margin).moveh(x: -@x + @d, y: @y - @d),
         cylinder(d:@d).moveh(x: @x - @d, y: @y - @d),
         cylinder(d:@d).moveh(x: -@x + @d, y: -@y + @d),
         cylinder(d:@d).moveh(x: @x - @d, y: -@y + @d),
       )
 
-      if @opts[:flat_edges]
-        if @opts[:flat_edges].kind_of?(Array)
-          @opts[:flat_edges].each do |e|
-            res += flat_edge(e)
-          end
-        else
-          res += flat_edge(@opts[:flat_edges])
-        end
-      end
+      res += flat_edge(@opts[:flat_edges])
 
       res.transformations = @transformations
       res
@@ -62,6 +55,9 @@ module JennCad::Primitives
 
     def flat_edge(edge)
       case edge
+      when Array
+        #ruby2.7 test- edge.map(&self.:flat_edge)
+        edge.map{|x| flat_edge(x) }
       when :up
         cube(@x, @y/2.0, @z).moveh(y:@y/2.0)
       when :down
@@ -70,6 +66,8 @@ module JennCad::Primitives
         cube(@x/2.0, @y, @z).moveh(x:@x/2.0)
       when :left
         cube(@x/2.0, @y, @z).moveh(x:-@x/2.0)
+      else
+        nil
       end
     end
 

data/lib/jenncad/primitives/subtract_object.rb

@@ -44,37 +44,41 @@ module JennCad::Primitives
       else
         compare_z(others, first_h.first, first_z.first)
       end
+      self
     end
 
-    # FIXME
-    # this won't work reliable with Aggregations at the moment;
-    # they don't have calc_z for comparing with the top
-    # and it will try to move the Aggregation which it should not do
-    # (it should move the calls to the Aggregation, not the Aggregation itself)
     def compare_z(others,compare_h,compare_z)
       others.each do |part|
         #puts part.inspect
         #puts "#{part.calc_z+part.calc_h} ; #{compare_h}"
         if part.respond_to? :z
+          part.opts[:margins] ||= {}
           if part.referenced_z && part.z != 0.0
             case part
             when JennCad::BooleanObject
+            when JennCad::Aggregation
             else
-              part.z+=0.2
-              part.translate(z:-0.1)
+              pp part if part.opts[:debug]
+              part.opts[:margins][:z] ||= 0.0
+              unless part.opts[:margins][:z] == 0.2
+                part.opts[:margins][:z] = 0.2
+                part.mz(-0.1)
+              end
             end
           elsif part.z == compare_h
 #            puts "fixing possible z fighting: #{part.class} #{part.z}"
-            part.z+=0.008
-            part.translate(z:-0.004)
+            part.opts[:margins][:z] += 0.008
+            part.mz(-0.004)
           elsif part.calc_z == compare_z
 #            puts "z fighting at bottom: #{part.calc_z}"
-            part.z+=0.004
-            part.translate(z:-0.002)
+            part.opts[:margins][:z] += 0.004
+           # part.z+=0.004
+            part.mz(-0.002)
           elsif part.calc_z.to_f+part.calc_h.to_f == compare_h
 #            puts "z fighting at top: #{compare_h}"
-            part.z+=0.004
-            part.translate(z:0.002)
+            #part.z+=0.004
+            part.opts[:margins][:z] += 0.004
+            part.mz(0.002)
           end
         end
       end

data/lib/jenncad/primitives.rb

@@ -0,0 +1,20 @@
+require "jenncad/primitives/primitive"
+require "jenncad/primitives/circle"
+require "jenncad/primitives/cylinder"
+require "jenncad/primitives/sphere"
+require "jenncad/primitives/cube"
+require "jenncad/primitives/rounded_cube"
+require "jenncad/primitives/polygon"
+require "jenncad/primitives/slot"
+require "jenncad/primitives/boolean_object"
+require "jenncad/primitives/union_object"
+require "jenncad/primitives/subtract_object"
+require "jenncad/primitives/hull_object"
+require "jenncad/primitives/intersection_object"
+require "jenncad/primitives/projection"
+require "jenncad/primitives/linear_extrude"
+require "jenncad/primitives/rotate_extrude"
+
+module JennCad
+  include Primitives
+end

data/lib/jenncad/shortcuts.rb

@@ -38,6 +38,10 @@ module JennCad
     OpenScadImport.new(import, name, args)
   end
 
+  def stl(file, args={})
+    StlImport.new(file, args)
+  end
+
   def extrude(args)
     LinearExtrude.new(self, args)
   end
@@ -54,56 +58,47 @@ module JennCad
     UnionObject.new(*args)
   end
 
-  def +(args)
-    return args if self == nil
-    if self.kind_of?(UnionObject) && self.transformations.size == 0
-      self.add(args)
-      return self
-    else
-      UnionObject.new(self,args)
-    end
-  end
-
   def subtraction(*args)
     SubtractObject.new(*args)
   end
 
-  def -(args)
-    if self.kind_of?(SubtractObject) && self.transformations.size == 0
-      self.add(args)
-      return self
-    else
-      SubtractObject.new(self,args)
-    end
-  end
-
   def intersection(*args)
     IntersectionObject.new(*args)
   end
 
-  def *(args)
-    if self.kind_of?(IntersectionObject) && self.transformations.size == 0
-      self.add(args)
-      return self
-    else
-      IntersectionObject.new(self,args)
-    end
-  end
-
   def hull(*args)
     HullObject.new(*args)
   end
 
-  def &(args)
-    if self.kind_of?(HullObject) && self.transformations.size == 0
-      self.add(args)
-      return self
-    else
-      HullObject.new(self,args)
-    end
+  def +(part)
+    boolean_operation(part, UnionObject)
+  end
+
+  def -(part)
+    boolean_operation(part, SubtractObject)
+  end
+
+  def *(part)
+    boolean_operation(part, IntersectionObject)
+  end
+
+  def &(part)
+    boolean_operation(part, HullObject)
   end
 
   def assemble(partlib=nil, z_skip = false, z=0, &block)
     block.yield.assemble(partlib, z_skip, z)
   end
+
+  private
+  def boolean_operation(part, klass)
+    case self
+    when nil
+      part
+    when klass
+      add_or_new(part)
+    else
+      klass.new(self,part)
+    end
+  end
 end

data/lib/jenncad/thing.rb

@@ -3,10 +3,10 @@ module JennCad
     attr_accessor :opts
     attr_accessor :parts
     attr_accessor :transformations, :name
-    attr_accessor :x, :y, :z, :diameter
+    attr_accessor :x, :y, :diameter
     attr_accessor :calc_x, :calc_y, :calc_z, :calc_h
     attr_accessor :shape
-    attr_accessor :angle, :cut, :fn
+    attr_accessor :angle, :fn
 
     def initialize(args={})
       @transformations = []
@@ -35,37 +35,46 @@ module JennCad
     end
     alias :rt :rotate
 
-    def center
-      return @center if @center
-      case shape.to_s
-        when "cube"
-          [@x/2.0,@y/2.0,@z/2.0]
-        when "cylinder"
-          [0,0,@z/2.0]
-      else
-        [0,0,0]
-      end
+    def rx(v)
+      rt(x:v)
     end
 
-    def flip_x
-      if self.kind_of?(BooleanObject)
+    def ry(v)
+      rt(y:v)
+    end
+
+    def rz(v)
+      rt(z:v)
+    end
+
+    def flip(direction)
+      case self
+      when UnionObject
+        ref = self.parts.first
+        rz = self.z.to_f + self.calc_h.to_f
+      when BooleanObject
         ref = self.parts.first
+        rz = ref.calc_z + ref.calc_h
       else
         ref = self
+        rz = self.z + self.calc_h
       end
 
-      self.rotate(y:90).moveh(x: -ref.z, z: ref.x)
+      case direction
+      when :x
+        self.ry(90).mh(x: -rz, z: ref.x)
+      when :y
+        self.rx(90).mh(y: rz, z: ref.y)
+      end
+    end
+
+    def flip_x
+      flip(:x)
     end
     alias :fx :flip_x
 
     def flip_y
-      if self.kind_of?(BooleanObject)
-        ref = self.parts.first
-      else
-        ref = self
-      end
-
-      self.rotate(x:90).moveh(y: ref.z, z: ref.y)
+      flip(:y)
     end
     alias :fy :flip_y
 
@@ -242,26 +251,109 @@ module JennCad
       item
     end
 
+    def has_explicit_color?
+      if option(:auto_color) == false
+        return true
+      end
+      return false
+    end
+
+    def only_color?(parts, lvl=0)
+      return true if parts == nil
+
+      parts.each do |part|
+#        puts "  " * lvl + "[only_color?] #{part}"
+        if part.has_explicit_color?
+#          puts "  " * lvl + "found explicit color here"
+          return false
+        end
+        if !only_color?(part.parts, lvl+1)
+          return false
+        end
+      end
+      true
+    end
+
+    def set_auto_color_for_children(col, parts, lvl=0)
+      return if parts == nil
+
+      parts.each do |part|
+        unless part.has_explicit_color?
+          if only_color?(part.parts, lvl+1)
+#            puts "  " * lvl + "children have no explicit color, setting it here"
+            part.set_auto_color(col)
+          else
+#            puts "  " * lvl + "[set_auto_color_for_children] #{part}"
+            set_auto_color_for_children(col, part.parts, lvl+1)
+          end
+        else
+#          puts "  " * lvl + "[set_auto_color_for_children] this part has a color, ignoring their children"
+        end
+
+      end
+    end
+
+    def set_auto_color(col)
+      set_option :color, col
+      set_option :auto_color, true
+    end
+
     def color(args=nil)
-      return option(:color) if args == nil
+      if args == nil
+        return option(:color)
+      end
+
       if args == :auto
-        return auto_color!
-      elsif args == :none
-        set_option :no_auto_color, true
+        ac = auto_color
+        unless ac.nil?
+          #puts "auto color to #{ac}"
+          if only_color?(self.parts)
+            set_option :color, ac
+            set_option :auto_color, true
+          else
+            set_auto_color_for_children(ac, self.parts)
+          end
+
+        end
         return self
       end
-      set_option :color, args
+
+      c = color_parse(args)
+      unless c.nil?
+        set_option :color, c
+        set_option :auto_color, false
+      end
+
       self
     end
 
+    def color_parse(args=nil)
+      case args
+      when :none
+        set_option :no_auto_color, true
+      when :random
+        return Color.random
+      when Array
+        return Color.parse(args)
+      when /(?<=#)(?<!^)(\h{6}|\h{3})/
+        return args
+      when /(?<!^)(\h{6}|\h{3})/
+        return "##{args}"
+      when String
+        return args
+      end
+      nil
+    end
+
     def auto_color
       if option(:color) == nil && !option(:no_auto_color)
-        auto_color!
+        return auto_color!
       end
+      nil
     end
 
     def auto_color!
-      color($jenncad_profile.colors.pop)
+      color_parse($jenncad_profile.colors.pop)
     end
 
     def color_or_fallback
@@ -273,14 +365,10 @@ module JennCad
       if @parts == nil
         if self.respond_to? :part
           @parts = [part]
-        else
-          # FIXME: -> move logic OpenScad
-          #puts "[Error in openscad export] Could not find @parts or part for #{self}"
-          #exit
         end
       end
 
-      OpenScad.new(self).save(file)
+      JennCad::Exporters::OpenScad.new(self).save(file)
     end
 
     def referenced_z
@@ -289,19 +377,27 @@ module JennCad
      return false
     end
 
+    def z=(args)
+      set_option(:z, args)
+      @z = args
+    end
+
     def z
-      ref = referenced_z
-      if ref
-        return ref.z.to_f + ref.z_margin.to_f
+      case ref = referenced_z
+      when nil, false
+        @z + z_margin
+      else
+        ref.z.to_f + ref.z_margin.to_f
       end
-      @z
     end
 
     def z_margin
-      if option(:margins)
-        return option(:margins)[:z].to_f
+      case m = option(:margins)
+      when nil, {}
+        0.0
+      else
+        m[:z].to_f
       end
-      0.0
     end
 
   end