jenncad 1.0.0.pre.alpha1 → 1.0.0.pre.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81f68c07dc7fd50719d6ce024f56eb25712ef97c9b31568dcfa6658d9fa01596
-  data.tar.gz: 3c877488f386a7d7c6f8dd3b1543ca84641316ae2dbd5d6bcbb4577fbf94ae7c
+  metadata.gz: ef018e45bc6303b2a45c2ad3340d714cb340288465936f23293961fbc2615cd4
+  data.tar.gz: 1ee41eb205053ad3ea4e0d1b8c76b4fa13c98f212393e71008e96f1303b0f9c7
 SHA512:
-  metadata.gz: 9a95e7f398d275b81bfb4c9bbe21d3bd0e306708f0ef514e8391f50837eab066ec7aaca3ee46e4bbb08cd4a0c3fbee009b899b87aea2b5fe86ea5a74f6294ee3
-  data.tar.gz: 5425a1f502e12c8b8300995f921b2e9ce1d10f214728f5f2b6508610aa783f76907f3ffcc9bb40ed88e997302a12a896dc7afa9c544d6e3f0216750e4914e37f
+  metadata.gz: b9541672a102b371b7a517be6d015ca1bc6e4f81fae97761399514733870bc1b0c67094b6a6e177c1c5af7d85416067e9b6dab024bff275b4537013f88072fc2
+  data.tar.gz: 44d0ae2e9aefb56e1964cf2e0fdf0590be5fc600abea1d65f3edcf40fca03a57bf6e107020dd26ec2ffac6a3f4c9f6b6f3688cdbcb72489766984b3011c8abd3

data/jenncad.gemspec

@@ -19,9 +19,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = ">= 2.5.0"
+  gem.required_ruby_version = ">= 2.6.0"
   gem.add_runtime_dependency "geo3d"
   gem.add_runtime_dependency "deep_merge"
   gem.add_runtime_dependency "hanami-cli"
   gem.add_runtime_dependency "activesupport"
+  gem.add_runtime_dependency "observr"
 end

data/lib/jenncad/default_profile.rb

@@ -17,8 +17,8 @@ module JennCad
     end
 
     def colors
-      @colors ||= []
-      if @colors.empty?
+      case @colors
+      when nil, []
         @colors = auto_colors
       end
       @colors

data/lib/jenncad/exporters/openscad.rb

@@ -0,0 +1,248 @@
+module JennCad::Exporters
+  class OpenScadObject
+    def initialize(cmd, args, children=[])
+      @command = cmd
+      @args = args
+      case children
+      when Array
+        @children = children
+      else
+        @children = [children]
+      end
+    end
+
+    def nl
+      "\n"
+    end
+
+    def to_s
+      case @command
+      when nil
+        ""
+      when :head
+        res = "$fn=64;"+nl
+        @children.each do |c|
+          res += c.to_s+nl
+        end
+        res
+      when :module
+        handle_module
+      when String, Symbol
+        handle_command
+      else
+      end
+    end
+
+    def handle_module
+      res = "module #{@args}(){"+nl
+      res += tabs(1, @children.map{|c| c.handle_command(2) })
+      res += "}"
+      res
+    end
+
+    def handle_command(i=1)
+      case @children.size
+      when 0
+        "#{@command}(#{handle_args});"
+      when 1
+        "#{@command}(#{handle_args})#{@children.first.handle_command(i+1)}"
+      when (1..)
+        res = "#{@command}(#{handle_args}){"
+        res += nl
+        inner = @children.map do |c|
+          next if c == nil
+          c.handle_command(i+1)
+        end
+        res += tabs(i, inner.compact)
+        res += nl
+        res += tabs(i-1,["}"])+nl
+        res
+      end
+    end
+
+    def tabs(i,a)
+      a.map{ |l|
+        "  " * i + l
+      }.join(nl)
+    end
+
+    def handle_args
+      case @args
+      when String, Symbol
+        return "\"#{@args}\""
+      when 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
+      when Hash
+        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(",").gsub("size=","")
+      else
+        ""
+      end
+    end
+  end
+
+  class OpenScad
+    include ActiveSupport::Inflector
+    def initialize(part)
+      @imports = []
+      @modules = {}
+      @global_fn = 64
+      @object_tree = OpenScadObject.new(:head, nil, parse(part))
+    end
+
+    def save(file)
+      File.open(file,"w") do |f|
+        @imports.uniq.each do |val|
+          f.puts "use <#{val}.scad>\n"
+        end
+
+        @modules.each do |key, val|
+          f.puts val.to_s
+        end
+        f.puts @object_tree.to_s
+      end
+    end
+
+    def parse(part)
+      if part.respond_to? :to_openscad
+        part = part.to_openscad
+      end
+
+      if part.respond_to? :analyze_z_fighting
+        part = part.analyze_z_fighting
+      end
+
+      case part
+      when Array
+        part.map{ |p| parse(p) }
+      when JennCad::OpenScadImport
+        handle_import(part)
+      when JennCad::Aggregation
+        handle_aggregation(part)
+      when JennCad::UnionObject
+        bool('union', part)
+      when JennCad::SubtractObject
+        bool('difference', part)
+      when JennCad::IntersectionObject
+        bool('intersection', part)
+      when JennCad::HullObject
+        bool('hull', part)
+      when JennCad::Primitives::Circle
+        prim('circle', part)
+      when JennCad::Primitives::Cylinder
+        prim('cylinder', part)
+      when JennCad::Primitives::Sphere
+        prim('sphere', part)
+      when JennCad::Primitives::Cube
+        prim('cube', part)
+      when JennCad::Primitives::LinearExtrude
+        new_obj(part, :linear_extrude, part.openscad_params, parse(part.parts))
+      when JennCad::Primitives::RotateExtrude
+        new_obj(part, :rotate_extrude, part.openscad_params, parse(part.parts))
+      when JennCad::Primitives::Projection
+        new_obj(part, :projection, collect_params(part), parse(part.parts))
+      when JennCad::Primitives::Polygon
+        new_obj(part, :polygon, collect_params(part))
+      when JennCad::Part
+        parse(part.part)
+      when nil
+        new_obj(part, nil)
+      else
+        puts "unknown part #{part.class}"
+        OpenScadObject.new(nil,nil)
+      end
+    end
+
+    def new_obj(part, cmd, args=nil, children=[])
+      transform(part) do
+        apply_color(part) do
+          OpenScadObject.new(cmd, args, children)
+        end
+      end
+    end
+
+    def bool(type, part)
+      new_obj(part, type, nil, parse(part.parts))
+    end
+
+    def prim(type, part)
+      new_obj(part, type, collect_params(part))
+    end
+
+    def collect_params(part)
+      res = {}
+      [:d, :h, :d1, :d2, :size, :fn, :points].each do |var|
+        if part.respond_to? var
+          res[var] = part.send var
+        end
+      end
+      case res[:fn]
+      when @global_fn
+        res[:fn] = nil
+      else
+      end
+      res
+    end
+
+    def apply_color(part, &block)
+      return block.yield if part.nil? or part.color_or_fallback.nil?
+      OpenScadObject.new("color", part.color_or_fallback, block.yield)
+    end
+
+    def transform(part, &block)
+      return block.yield if part.transformations.nil?
+
+      case t = part.transformations.pop
+      when nil, []
+        block.yield
+      when JennCad::Move
+        OpenScadObject.new(:translate, t.coordinates, transform(part, &block))
+      when JennCad::Rotate, JennCad::Mirror
+        OpenScadObject.new(demodulize(t.class).downcase, t.coordinates, transform(part, &block))
+      when JennCad::Multmatrix
+        OpenScadObject.new(:multmatrix, t.m, transform(part, &block))
+      else
+        puts "unknown transformation #{t}"
+      end
+    end
+
+    def handle_aggregation(part, tabindex=0)
+      register_module(part) unless @modules[part.name]
+      transform(part) do
+        new_obj(part, part.name, nil)
+      end
+    end
+
+    # accept aggregation
+    def register_module(part)
+      @modules[part.name] = OpenScadObject.new(:module,part.name, parse(part.part))
+    end
+
+    def handle_import(part)
+      @imports << part.import
+      new_obj(part, part.name, part.args)
+    end
+  end
+end

data/lib/jenncad/part.rb

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

data/lib/jenncad/patches/array.rb

@@ -19,11 +19,32 @@ class Array
     .union
   end
 
-  def union(&block)
-    if block
-      UnionObject.new(block.yield)
-    else
-      UnionObject.new(self)
-    end
+  def union
+    UnionObject.new(self)
+  end
+  alias u union
+
+  def subtraction
+    SubtractObject.new(self)
   end
+  alias subtract subtraction
+  alias sub subtraction
+  alias s subtraction
+
+  def intersection
+    IntersectionObject.new(self)
+  end
+  alias intersect intersection
+  alias i intersection
+
+  def hull
+    HullObject.new(self)
+  end
+  alias h hull
+
+
+  def random
+    self[Random.rand(size)]
+  end
+
 end

data/lib/jenncad/primitives/boolean_object.rb

@@ -10,6 +10,16 @@ module JennCad::Primitives
       after_add
     end
 
+    def add_or_new(part)
+      case @transformations
+      when nil, []
+        add(part)
+        self
+      else
+        self.class.new(self, part)
+      end
+    end
+
     def add(part)
       @parts << part
       after_add
@@ -39,7 +49,7 @@ module JennCad::Primitives
 
     def inherit_zref
       return if @parts.first == nil
-      return if @parts.first.z.to_f == 0.0
+      #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

data/lib/jenncad/primitives/cube.rb

@@ -1,6 +1,5 @@
 module JennCad::Primitives
   class Cube < Primitive
-    attr_accessor :x,:y,:z
 
     def initialize(args)
       if args.kind_of?(Array) && args[0].kind_of?(Hash)
@@ -37,33 +36,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

@@ -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,45 @@ 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 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
+    end
+
     def h
-      z
+      z + z_margin
     end
 
   end

data/lib/jenncad/primitives/rounded_cube.rb

@@ -40,21 +40,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 +54,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 +65,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,22 @@
+require "jenncad/primitives/primitive"
+require "jenncad/primitives/aggregation"
+require "jenncad/primitives/openscad_include"
+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