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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81f68c07dc7fd50719d6ce024f56eb25712ef97c9b31568dcfa6658d9fa01596
-  data.tar.gz: 3c877488f386a7d7c6f8dd3b1543ca84641316ae2dbd5d6bcbb4577fbf94ae7c
+  metadata.gz: ea1fa04592f59d248c5801c3b645f16429bd7ae9f0b754aa467c8a401c89ec4b
+  data.tar.gz: 4df185f63b22b5945784cf820b4af937e4fbc660875f36093bbd5ebe9baa2aa9
 SHA512:
-  metadata.gz: 9a95e7f398d275b81bfb4c9bbe21d3bd0e306708f0ef514e8391f50837eab066ec7aaca3ee46e4bbb08cd4a0c3fbee009b899b87aea2b5fe86ea5a74f6294ee3
-  data.tar.gz: 5425a1f502e12c8b8300995f921b2e9ce1d10f214728f5f2b6508610aa783f76907f3ffcc9bb40ed88e997302a12a896dc7afa9c544d6e3f0216750e4914e37f
+  metadata.gz: '0809987ec1b33518b17402acb27b659da2dc7b97ee304d1549abd857ae4448e0342d6ee4523e8d2277d7ce765e1278f996af9882b5da91b71c93acec8bd9ffd9'
+  data.tar.gz: e412b05272163c37096d36a44d83ac3d3c5ae07089d7d8d7236c1c53a263c24742566b691efbb5a03c9148960cb7734eb2859bc279e450e34c131fda2ae85af5

data/README.md

@@ -0,0 +1,83 @@
+
+# jenncad
+Create physical objects in Ruby, OpenScad export
+
+This is a successor to my older project CrystalScad. 
+
+# Installation
+
+A packaged release is not yet available, please build your own package in the meantime:
+
+    $ git clone git@github.com:jglauche/jenncad.git
+    $ cd jenncad
+    $ rake install
+
+This will create a gem and a binary jenncad. 
+
+# Using Jenncad
+
+**To create a new project directory, run:**
+
+    $ jenncad create meow
+   
+
+
+
+This will generate a directory meow/ and an executable ruby file meow.rb in its directory
+
+    $ cd meow
+    $ ./meow
+
+This will generate a dummy project which generates a dummy cube as  OpenSCAD output:
+
+    $ cat output/meow.scad 
+> $fn=64;
+> translate([-5, -5, 0])cube([10, 10, 10.0]);
+
+**Automatically refresh OpenSCAD output while developing**
+
+Jenncad bundles the observr gem which will check if files were changed while developing. In the project directory run:
+
+    $ jenncad
+This should display something like:
+> refreshing... 
+> ok 
+> JennCad running, refreshing on file changes. Press ctrl+c to exit
+
+**Note:** This does not check for new files in the project. You will have to restart it when you create a new part in a new file
+
+**Create new part**
+
+In your project directory, run:
+
+    $ jenncad new cat
+    part parts/cat.rb created. In your meow.rb add to class Meow:
+    def cat
+      Cat.new(config)
+    end
+
+
+You will have to link the part to the project manually into the meow.rb file in your project directory. When you add it, your meow.rb should look like this:
+
+    #!/usr/bin/env ruby
+    require "jenncad"
+    include JennCad
+    
+    class Meow < Project
+      def config
+        {}
+      end
+    
+      def meow
+        cube(10,10,10)
+      end
+    
+      def cat
+        Cat.new(config)
+      end
+    
+    end
+    Meow.new.run
+
+ 
+

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,260 @@
+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
+          if v.kind_of? String
+            q = "\""
+          else
+            q = ""
+          end
+          res << "#{k}=#{q}#{v}#{q}"
+        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::StlImport
+        new_obj(part, :import, 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)
+      if part.respond_to? :openscad_params
+        return part.openscad_params
+      end
+      res = {}
+      [:d, :h, :d1, :d2, :size, :fn, :points, :file].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::Scale
+        OpenScadObject.new(:scale, t.scale, 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/features/aggregation.rb

@@ -0,0 +1,16 @@
+module JennCad::Features
+  class Aggregation < Feature
+    attr_accessor :parts
+
+    def initialize(name=nil, part=nil)
+      super({})
+      @name = name
+      @parts = [part] # NOTE: single length arrayto make checking children easier
+    end
+
+    def part
+      @parts.first
+    end
+
+  end
+end

data/lib/jenncad/features/climb.rb

@@ -0,0 +1,95 @@
+module JennCad::Features
+  class Climb < Feature
+    def initialize(opts, block)
+      @opts = {
+        offset: :auto,
+        step: nil,
+        steps: nil,
+        bottom: nil,
+        top: nil,
+        z: nil,
+      }.deep_merge!(opts)
+      if @opts[:step].nil? && @opts[:steps].nil?
+        raise "please define at least one of :step or :steps for climb"
+      end
+      super(@opts)
+      @block = block
+    end
+
+    def z_or_referenced
+      case z = @opts[:z]
+      when nil
+        referenced_z.z
+      else
+        z
+      end
+    end
+
+    def get_step(z)
+      case step = @opts[:step]
+      when nil, :auto, 0, 0.0
+        steps = @opts[:steps]
+        (z  / steps).floor
+      else
+        step.to_f
+      end
+    end
+
+    def get_offset(z)
+      case offset = @opts[:offset]
+      when :auto
+        step = get_step(z)
+        ((z % step) + step) / 2.0
+      when nil, 0, 0.0
+        0.0
+      else
+        offset
+      end
+    end
+
+    def climb_from_bottom(offset, step, n)
+      n.times.map{ |i| @block.yield.mz(offset+step*i) }.union
+    end
+
+    def climb_from_top(z, offset, step, n)
+      n.times.map{ |i| @block.yield.mz(z-offset-step*i) }.union
+    end
+
+    def to_openscad
+      ref_z = z_or_referenced
+      step = get_step(ref_z)
+      steps, top, bottom = @opts.values_at(:steps, :top, :bottom)
+
+      offset = get_offset(ref_z)
+
+      lo = (ref_z-offset*2).to_f % step.to_f
+      unless lo.to_f == 0.0
+        puts "[Warning]: climb has leftover offset #{lo}"
+      end
+
+      if steps
+        top = steps
+        bottom = steps
+      end
+
+      unless top or bottom
+        climb_from_bottom(offset, step, ((ref_z-offset*2) / step).floor + 1 )
+      else
+        res = nil
+        if top
+          res += climb_from_top(ref_z, offset, step, top)
+        end
+        if bottom
+          res += climb_from_bottom(offset, step, bottom)
+        end
+        res
+      end
+    end
+
+  end
+
+  def climb(args, &block)
+    Climb.new(args, block)
+  end
+
+end

data/lib/jenncad/features/cuttable.rb

@@ -0,0 +1,35 @@
+module JennCad::Features
+  module Cuttable
+    def cut(args, &block)
+      if args[:x]
+        l = args[:x].min * @opts[:y] / 2.0
+        r = args[:x].max * @opts[:y] / 2.0
+        prepare_cut(l, r, &block).flip_x
+      elsif args[:y]
+        l = args[:y].min * @opts[:y] / 2.0
+        r = args[:y].max * @opts[:y] / 2.0
+        prepare_cut(l, r, &block).flip_y
+      elsif args[:z]
+        raise "cut for Z is not implemented yet"
+      end
+    end
+
+    def prepare_cut(l, r, &block)
+      part = block.call
+      if part.z.to_f > 0.0
+        part.opts[:margins][:z] = 0.2
+        if l == 0.0
+          part.mz(r+0.1)
+        else
+          part.mz(l+part.z.to_f-0.2)
+        end
+      else
+        part.opts[:margins][:z] = 0.2
+        part.z = l.abs + r.abs + 0.2
+        part.mz(-0.1)
+      end
+    end
+
+
+  end
+end

data/lib/jenncad/features/feature.rb

@@ -0,0 +1,4 @@
+module JennCad::Features
+  class Feature < JennCad::Thing
+  end
+end

data/lib/jenncad/{primitives → features}/openscad_include.rb

@@ -1,4 +1,4 @@
-module JennCad::Primitives
+module JennCad::Features
   class OpenScadImport < Aggregation
     attr_accessor :import, :args
 

data/lib/jenncad/features/stl_import.rb

@@ -0,0 +1,10 @@
+module JennCad::Features
+  class StlImport < Feature
+    attr_accessor :file, :args
+
+    def initialize(file, args={})
+      @file = file
+      @args = args
+    end
+  end
+end

data/lib/jenncad/features.rb

@@ -0,0 +1,11 @@
+require "jenncad/features/feature"
+require "jenncad/features/aggregation"
+require "jenncad/features/cuttable"
+require "jenncad/features/openscad_include"
+require "jenncad/features/climb"
+require "jenncad/features/stl_import"
+
+
+module JennCad
+  include Features
+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
-      auto_color
-      a = Aggregation.new(self.class.to_s, make_openscad_compatible!(self.part))
+    def to_openscad #make_openscad_compatible
+#      auto_color
+      a = Aggregation.new(self.class.to_s, self.part) #make_openscad_compatible!(self.part))
       a.transformations = @transformations
-      a.color(color)
+      a.color(:auto)
       a
     end
 
+    def part
+    end
+
   end
 end

data/lib/jenncad/patches/array.rb

@@ -12,18 +12,38 @@ class Array
       else
         res = part
       end
-      # FIXME: I added 0.01 to all for now to fix z-fighting issues; this should not be hardcoded like this
-      res, z = res.move(z:z), z + res.z.to_f + 0.01 unless skip_z
+      res, z = res.mz(z), z + res.z.to_f unless skip_z
       res
     end
     .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