jenncad 1.0.0.pre.alpha8 → 1.0.0.pre.alpha11

data/lib/jenncad/primitives/cube.rb

@@ -2,6 +2,7 @@ module JennCad::Primitives
   class Cube < Primitive
     extend JennCad::Features::Cuttable
 
+    attr_accessor :corners, :sides
 
     def feed_opts(args)
       # FIXME: this doesn't seem to work
@@ -46,8 +47,102 @@ module JennCad::Primitives
       super(z: @opts[:z])
       @h = @z.dup
       @calc_h = @z.dup
+
+
+      set_anchors
+    end
+
+    def set_anchors
+      @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)
+      @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
+
+
     # used for openscad export
     def size
       [@x, @y, z+z_margin]
@@ -55,6 +150,7 @@ module JennCad::Primitives
 
     def not_centered
       @opts[:center] = false
+      set_anchors
       self
     end
     alias :nc :not_centered
@@ -62,20 +158,27 @@ module JennCad::Primitives
     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 cz
       nc
       @opts[:center_z] = true
+      set_anchors
       self
     end
+    alias :center_z :cz
 
     def centered_axis
       return [:x, :y] if @opts[:center]

data/lib/jenncad/primitives/rounded_cube.rb

@@ -22,7 +22,7 @@ module JennCad::Primitives
         y: 0,
         z: nil,
         r: nil,
-        flat_edges: nil,
+        flat_edges: [],
         center: true,
         center_y: false,
         center_x: false,
@@ -45,32 +45,42 @@ module JennCad::Primitives
       # 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),
-      ).moveh(xy: d)
+        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),
+      )
+      res = res.move(xy: d/2.0)
 
-      res += flat_edge(@opts[:flat_edges])
+      @opts[:flat_edges].each do |edge|
+        res += apply_flat_edge(edge)
+      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
+
       res.moveh(centered_axis.to_h{|a| [a, -@opts[a]] })
+      res.inherit_color(self)
       res
     end
 
-    def flat_edge(edge)
+    def flat(edge)
+      @opts[:flat_edges] ||= []
+      @opts[:flat_edges] << edge
+      self
+    end
+
+    private
+    def apply_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)
+        cube(x: @x, y: @y/2.0, z: @z).nc.moveh(y:@y)
       when :down
-        cube(@x, @y/2.0, @z).moveh(y:-@y/2.0)
+        cube(x: @x, y: @y/2.0, z: @z).nc
       when :right
-        cube(@x/2.0, @y, @z).moveh(x:@x/2.0)
+        cube(x: @x/2.0, y: @y, z: @z).nc.moveh(x:@x)
       when :left
-        cube(@x/2.0, @y, @z).moveh(x:-@x/2.0)
+        cube(x: @x/2.0, y: @y, z: @z).nc
       else
         nil
       end

data/lib/jenncad/primitives/subtract_object.rb

@@ -3,10 +3,16 @@ module JennCad::Primitives
     def inherit_z
       @z = 0
       @calc_z = parts.first.calc_z.to_f
+
       only_additives_of(@parts).each do |p|
+        if option(:debug)
+          $log.debug "inherit_z checks for: #{p}"
+        end
         z = p.z.to_f
         @z = z if z > @z
       end
+      $log.debug "inherit_z called, biggest z found: #{@z}" if option(:debug)
+
     end
 
     def get_heights(obj)
@@ -57,9 +63,8 @@ module JennCad::Primitives
             case part
             when JennCad::Circle
             when JennCad::BooleanObject
-            when JennCad::Aggregation
             else
-              pp 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
                 part.opts[:margins][:z] = 0.2
@@ -67,7 +72,7 @@ module JennCad::Primitives
               end
             end
           elsif part.z == compare_h
-#            puts "fixing possible z fighting: #{part.class} #{part.z}"
+            $log.debug "fixing possible z fighting: #{part.class} #{part.z}" if part.opts[:debug]
             part.opts[:margins][:z] += 0.008
             part.mz(-0.004)
           elsif part.calc_z == compare_z

data/lib/jenncad/shortcuts.rb

@@ -1,34 +1,34 @@
 module JennCad
   def circle(args)
-    Circle.new(args)
+    Circle.new(args).set_parent(self)
   end
 
   def cylinder(*args)
-    Cylinder.new(args)
+    Cylinder.new(args).set_parent(self)
   end
   alias :cy :cylinder
   alias :cyl :cylinder
 
   def sphere(args)
-    Sphere.new(args)
+    Sphere.new(args).set_parent(self)
   end
   alias :sp :sphere
 
   def polygon(args)
-    Polygon.new(args)
+    Polygon.new(args).set_parent(self)
   end
 
   def slot(*args)
-    Slot.new(args)
+    Slot.new(args).set_parent(self)
   end
 
   def cube(*args)
-    Cube.new(args)
+    Cube.new(args).set_parent(self)
   end
   alias :cu :cube
 
   def rounded_cube(*args)
-    RoundedCube.new(args)
+    RoundedCube.new(args).set_parent(self)
   end
   alias :rcube :rounded_cube
   alias :rc :rounded_cube

data/lib/jenncad/thing.rb

@@ -7,7 +7,8 @@ module JennCad
     attr_accessor :calc_x, :calc_y, :calc_z, :calc_h
     attr_accessor :shape
     attr_accessor :angle, :fn
-    attr_accessor :anchor
+    attr_accessor :anchors
+    attr_accessor :parent
 
     def initialize(args={})
       @transformations = []
@@ -16,6 +17,8 @@ module JennCad
       @calc_y = 0
       @calc_z = 0
       @calc_h = args[:z] || 0
+      @anchors = {}
+      @parent = args[:parent]
       @opts ||= args
     end
 
@@ -29,34 +32,30 @@ module JennCad
       @opts[key] = val
     end
 
-    def set_anchor(args)
-      self.anchor ||= {}
-      args.each do |key, val|
-        self.anchor[key] = val
-      end
+    def set_parent(parent)
+      @parent = parent
+      self
     end
 
-    def movea(key)
-      a = self.anchor[key]
-      unless a
-        puts "Error: Anchor #{key} not found"
-        puts "Available anchor: #{self.anchor}"
-        return self
-      else
-        self.movei(a)
+    def anchor(name, thing=nil)
+      if thing
+        return thing.anchor(name)
       end
-    end
-
-    def movei(args)
-      to = {}
-      [:x, :y, :z].each do |key|
-        if args[key]
-          to[key] = args[key]*-1
-        end
+      @anchors ||= {}
+      if anch = @anchors[name]
+        return anch
+      elsif @parent
+        return @parent.anchor(name)
       end
-      move(to)
     end
+    alias :a :anchor
 
+    def set_anchor(name, args={})
+      @anchors ||= {}
+      @anchors[name] = args
+      self
+    end
+    alias :sa :set_anchor
 
     def auto_extrude
       ret = self.extrude
@@ -138,10 +137,18 @@ module JennCad
     end
 
     def parse_xyz_shortcuts(args)
+      unless args.kind_of? Hash
+        $log.warn "parse_xyz_shortcuts called for type #{args.class} #{args.inspect}"
+        return args
+      end
       [:x, :y, :z].each do |key|
         args[key] ||= 0.0
       end
 
+      if args[:debug]
+        $log.debug "Args: #{args}"
+      end
+
       if args[:xy]
         args[:x] += args[:xy]
         args[:y] += args[:xy]
@@ -159,10 +166,14 @@ module JennCad
         args[:y] += args[:yz]
         args[:z] += args[:yz]
       end
-      return args
+      if args[:debug]
+        $log.debug "After xyz shortcuts #{args}"
+      end
+
+     return args
     end
 
-    def move(args)
+    def move(args={})
       if args.kind_of? Array
         x,y,z = args
         return move(x:x, y:y, z:z)
@@ -183,20 +194,45 @@ module JennCad
     alias :translate :move
     alias :m :move
 
-    def mx(v)
+    def mx(v=0)
       move(x:v)
     end
 
-    def my(v)
+    def my(v=0)
       move(y:v)
     end
 
-    def mz(v)
+    def mz(v=0)
       move(z:v)
     end
 
+    # move to anchor
+    def movea(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.move(an.dup)
+      end
+    end
+
+    # 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)
+      end
+    end
+
+
     # move half
-    def moveh(args)
+    def moveh(args={})
       if args.kind_of? Array
         x,y,z = args
         args = {x: x, y: y, z: z}
@@ -209,26 +245,49 @@ module JennCad
     end
     alias :mh :moveh
 
-    def mhx(v)
+    def mhx(v=0)
       moveh(x:v)
     end
 
-    def mhy(v)
+    def mhy(v=0)
       moveh(y:v)
     end
 
-    def mhz(v)
+    def mhz(v=0)
       moveh(z:v)
     end
 
-    def mirror(args)
+    def movei(args={})
+      to = {}
+      [:x, :y, :z, :xy, :xz, :yz, :xyz].each do |key|
+        if args[key]
+          to[key] = args[key]*-1
+        end
+      end
+      move(to)
+    end
+
+    def mirror(args={})
       @transformations ||= []
       @transformations << Mirror.new(args)
       self
     end
     alias :mi :mirror
 
-    def scale(args)
+    def miz
+      mirror(z:1)
+    end
+
+    def miy
+      mirror(y:1)
+    end
+
+    def miz
+      mirror(z:1)
+    end
+
+
+    def scale(args={})
       if args.kind_of? Numeric or args.kind_of? Array
           args = {v:args}
       end
@@ -313,6 +372,11 @@ module JennCad
     end
 =end
 
+    def inherit_color(other)
+      self.set_option(:color, other.option(:color))
+      self.set_option(:auto_color, other.option(:auto_color))
+    end
+
     def has_explicit_color?
       if option(:auto_color) == false
         return true

data/lib/jenncad/version.rb

@@ -1,4 +1,4 @@
 module JennCad
-  VERSION = "1.0.0-alpha8"
+  VERSION = "1.0.0-alpha11"
 end
 

data/lib/jenncad.rb

@@ -1,3 +1,6 @@
+require "logger"
+$log = Logger.new(STDOUT)
+
 require "geo3d"
 require "deep_merge"
 require "fileutils"

data/todo.txt

@@ -1,29 +1,59 @@
 1.0 required features
 ===================
 
-- cli needs to be a package manager for existing parts from a public library (i.e. bolts, motors go here), able to
--- query
--- download
--- update
-(upload? -> probably git pull request for now)
-- add external projects into one another (for example: make parts, show arrangement of a shelf in another project)
-
 - slot with square ends -> rounded cube with one side = d + flat_edges does that. Should slot do that in reverse?
 
-- de-centering a cube in one direction sucks, you have to add both center: false, center_x: true
-	-> decenter ?
-
 - bolt library needs to get a rewrite,
 	- fetching dimensions from the imported Bolt library should be less awful
 
 - needs a documentation and showcase
 
+Features wanted
+===================
+28.4.22:
+- Parts often come with 4 holes around a center, and I often do something like:
+
+[-1, 1].each do |i|
+	[-1, 1].each do |j|
+		res += @bolt.cut.move(x: @hole_center*i, y: @hole_center*j)
+	end
+end
+
+there should be a shorter way to do this.
+
+
+- instead of moving Bolts output, make it the default to make their positions an anchor
+
+- Bolt size data should be in a constant instead of one "Data" constant i.e.
+	M2_5.head_dia
+	M2_5.head_h
+	M2_5_hole
+
+- Bolt sizes should follow user configuration that can change margins
+- Bolts should have an easier way to align than mirror them, maybe from :top
+	 - but also, when you have a part that can be mounted in any top/bottom direction, 	you always end up having the bolts facing the wrong direction..
+- Bolts should be able to also make thread inserts
+
+
+
+
 other awful things
 ===================
 
-- command line interface isn't capable of adding parts to the output automatically
+- cli needs to use templates and user defined templates, profile loader needs to have this.
 
 - user profile file should be auto generated with examples
 
-- switching back and forth from and to openscad for preview sucks (that being said, switching from vim to something else would be awful to me)
+
+Future plans
+==================
+
+- cli needs to be a package manager for existing parts from a public library (i.e. bolts, motors go here), able to
+-- query
+-- download
+-- update
+(upload? -> probably git pull request for now)
+- add external projects into one another (for example: make parts, show arrangement of a shelf in another project)
+
+
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jenncad
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.alpha8
+  version: 1.0.0.pre.alpha11
 platform: ruby
 authors:
 - Jennifer Glauche
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-23 00:00:00.000000000 Z
+date: 2022-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: geo3d
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: TBD
 email:
 - "=^.^=@jenncad.kittenme.ws"
@@ -88,17 +102,11 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - Rakefile
 - bin/jenncad
-- examples/old/cube.rb
-- examples/old/slot.rb
-- examples/old/test.rb
-- examples/old/test1.rb
-- examples/old/test2.rb
-- examples/old/test3.rb
-- examples/old/test4.rb
-- examples/old/test5.rb
+- examples/README
 - jenncad.gemspec
 - lib/jenncad.rb
 - lib/jenncad/commands.rb
@@ -115,6 +123,7 @@ files:
 - lib/jenncad/features/cuttable.rb
 - lib/jenncad/features/feature.rb
 - lib/jenncad/features/openscad_include.rb
+- lib/jenncad/features/path.rb
 - lib/jenncad/features/stl_import.rb
 - lib/jenncad/part.rb
 - lib/jenncad/patches/array.rb

data/examples/old/cube.rb

@@ -1,12 +0,0 @@
-require 'rubygems'
-require 'jenncad'
-include JennCad
-
-# cubes are centered in x,y and flat to z=0 by default
-res = cube(40,30,20)
-# if symbols are omitted first argument of cylinder is d (diameter), second is height
-# if height is omitted, it will assume height of first suitable parent object. This only works for z direction
-# if height is omitted, it will also reward you with automatic z-fighting. For other cuts it'll try to do the same but is not so smart
-res -= cylinder(5)
-
-res.openscad("cube.scad")

data/examples/old/slot.rb

@@ -1,10 +0,0 @@
-require 'rubygems'
-require 'jenncad'
-include JennCad
-
-res = cube(30,30,10)
-
-res -= slot(d:10, x:20, a:30).move(x:5)
-res -= slot(d:10, x:20, a:-30).move(x:5)
-
-res.openscad("slot.scad")