solidruby 0.1.0

data/README.md

@@ -0,0 +1,180 @@
+SolidRuby
+===========
+
+SolidRuby is a framework for programming 2d and 3d OpenSCAD models in Ruby.
+It is a fork of [CrystalScad](https://github.com/Joaz/CrystalScad) with the aim to update and improve the codebase.
+
+SolidRuby, like CrystalScad and RubyScad on which it is based, is released under the GPLv3 license.
+
+[![Build Status](https://travis-ci.org/MC-Squared/SolidRuby.svg?branch=master)](https://travis-ci.org/MC-Squared/SolidRuby)
+
+Installation:
+===========
+
+Dependencies:
+
+- Ruby 1.9.3+
+
+Install via gem:
+```
+# gem install solidruby
+```
+
+if you have multiple ruby versions, you likely need to use gem1.9.3 instead of gem.
+
+Install via git:
+
+- clone repository
+- \# rake install
+
+Getting started
+===========
+SolidRuby comes with a generator that generates project stubs automatically for you. Run this command from a terminal in the directory that you want to create a project:
+
+```
+# solidruby new [my_project_name]
+```
+Change [my_project_name] to the name of your project
+
+A project named "my_project" will create those files and directories:
+
+- my_project/my_project.rb - the controller
+- my_project/lib/assemblies - for putting together assemblies of individual parts
+- my_project/lib/electronics - put electronics here
+- my_project/lib/hardware - put hardware parts in here
+- my_project/lib/printed - put parts that you want to print in here
+- my_project/lib/lasercut - put sheets that need to be cut (by laser or other) in here
+- my_project/lib/params.rb - place for global parameters
+- my_project/lib/assemblies/my_project_assembly.rb  - dummy assembly
+- my_project/Guardfile - guard
+
+A Guardfile is created to automatically update the output scad files.
+
+Coding
+===========
+Nearly all OpenSCAD functions are implemented. You can use the same parameters as in OpenSCAD, although SolidRuby provides some convenient variable names like diameter (d) for cylinders.
+
+Some examples:
+
+CSG Modeling:
+```
+res = cylinder(d:10, h:10)
+# union
+res += cube(x:5, y:20, z:20)
+# difference
+res -= cylinder(d:5, h:10)
+# intersection
+res *= cylinder(d:10, h:10)
+```
+
+Chain transformations:  
+```
+res = cube(1, 2, 3).rotate(x: 90).translate(x: 20, y: 2, z: 1).mirror(z: 1)
+```
+
+
+Hull:   
+```
+  res = hull(cylinder(d:10, h:10).cube(20, 10, 10].translate(x: 10)))
+```
+
+Center cubes in X/Y direction only:    
+```
+  cube(10, 10, 10).center_xy # note: only works on cubes and must be put before any transformations
+```
+
+Also implemented: center_x, center_y, center_z, center
+
+Helpers:
+
+Some helpers have been implemented to ease modelling.
+Where helpers take face/edge/corner the options are:
+```
+  faces: :top, :bottom, :left, :right, :front, :back, :center
+  edges: :top, :bottom, :left, :right, :front, :back, :center
+  corners: :left, :right, :center
+```
+For example:
+
+Triangles - can be either linear_extruded or simply used for calulations
+  triangle(alpha: 90, c: 5, b: 3) #a right triangle on the origin, with Y leg 5 units, X leg 3 units
+```
+triangle(alpha: 45, c: 6, b: 9).beta #get calulated angle from triangle
+```
+
+Filleted cubes
+Filled cubes can be created by using the .fillet helper:
+```
+cube(10).fillet(edges: :vertical, r: 2)
+cube(10).fillet(top: [:left, :right], front: :bottom, r: 2)
+```
+
+Chamfered cubes
+Similar to filleted cubes above
+```
+cube(10).chamfer(edges: :vertical, h: 2)
+```
+
+Both the fillet() and chamfer() helper can be used in isolation as well:
+```
+fillet(h: 10, r: 2)
+chamfer(l: 10, h: 2)
+```
+
+Rounded cubes:
+Due to how fillet is applied, the corners of a cube are not perfect when doing all sides.
+In this case you can use rounded_cube:
+```
+rounded_cube(x: 10, y: 10, z: 10, r: 2) #Actually a hull of 8 spheres
+```
+
+Hollow cylinders:
+Hollow cylinders can be created by indicating an :id argument (inner diameter)
+```
+cylinder(d: 10, id: 8, h: 10) #creates a fully hollow cylinder
+cylinder(d: 10, id: 8, h: 10, ih: 8) #inner cutout only partial height
+```
+
+Placing onto:
+For simple primitives you can use .place to place objects onto their faces:
+```
+  c = cube(10)
+  res = c + cube(5).place(onto: c, face: :top, edge: :top, corner: :center)
+
+  cy = cylinder(d: 10, h: 50)
+  res = cy + sphere(10).place(onto: cy, face: :top) #edge and corner default to center
+```
+
+Long slots:   
+```
+  # produces a hull of two cylinders, 14mm apart        
+  long_slot(d:4.4, h:10, l:14)  
+```
+
+Printed threads:
+There is a printed thread class for printing threads, i.e. for nuts and bolts:
+```
+t1 = PrintedThread.new(diameter: 20, pitch: 2.5, length: 22.5, internal: true)
+```
+
+
+A few tips:
+- Be visual. By running `guard` you can watch your updates in OpenSCAD
+
+- When porting OpenSCAD code, beware of dividing integers. Example:
+```
+cylinder(r=11/2, h=10);
+```
+needs to be ported to
+```
+cylinder(r:11/2.0, h:10)
+```
+or
+```
+cylinder(d:11, h:10)
+```
+
+
+License:
+===========
+GPLv3

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/solidruby

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'thor/group'
+require 'thor/actions'
+require 'solidruby'
+
+class SolidRubyGenerator < Thor
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__) + '/../lib/templates'
+  end
+
+  desc 'printed NAME', 'generate printed part'
+  def printed(name)
+    @clean_name = name.split(/[-|_]/).map { |s| s.capitalize }.join
+    template('printed.tt', "lib/printed/#{name}.rb")
+  end
+end
+
+class SolidRubyCli < Thor
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__) + '/../lib/templates'
+  end
+
+  desc 'version', 'shows the current version of SolidRuby'
+  def version
+    puts SolidRuby::VERSION
+  end
+
+  desc 'new APP_NAME', 'creates a new project stub'
+  def new(name)
+
+    @clean_name = name.split(/[-|_]/).map { |s| s.capitalize }.join
+    @name = name
+
+    empty_directory("#{name}/lib/assemblies/")
+    empty_directory("#{name}/lib/electronics/")
+    empty_directory("#{name}/lib/hardware/")
+    empty_directory("#{name}/lib/printed/")
+    empty_directory("#{name}/lib/lasercut/")
+    empty_directory("#{name}/output")
+    create_file("#{name}/output/.keep")
+
+    template('main.tt', "#{name}/#{name}.rb")
+    chmod("#{name}/#{name}.rb", 0755)
+
+    template('guardfile.tt', "#{name}/Guardfile")
+    template('gitignore.tt', "#{name}/.gitignore")
+    template('assembly.tt', "#{name}/lib/assemblies/#{name}_assembly.rb")
+    template('params.tt', "#{name}/lib/params.rb")
+  end
+
+  desc 'g COMMANDS', 'generator module'
+  subcommand 'g', SolidRubyGenerator
+end
+
+SolidRubyCli.start(ARGV)

data/examples/chamfered_cube.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'solidruby'
+include SolidRuby
+
+def chamfered_cube
+  edges = [:top, :bottom, :left, :right]
+  faces = [:top, :bottom, :left, :right, :front, :back]
+
+  res = nil
+  x = 0
+  y = 0
+
+  faces.each do |f|
+    edges.each do |e|
+      res += cube(x: 5, y: 5, z: 10).chamfer({f => e, h: 1})
+        .translate(x: x, y: y)
+
+        y += 10
+    end
+
+    x += 10
+    y = 0
+  end
+
+  res += cube(x: 5, y: 5, z: 10)
+    .chamfer(edges: :vertical, h: 1)
+    .translate(x: -10)
+
+  res += cube(x: 5, y: 5, z: 10)
+    .chamfer(edges: :horizontal, h: 1)
+    .translate(x: -10, y: 10)
+
+  res += cube(x: 5, y: 5, z: 10)
+    .chamfer(edges: :all, h: 1)
+    .translate(x: -10, y: 20)
+end
+
+chamfered_cube.save('chamfered_cube.scad')

data/examples/filleted_cube.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'solidruby'
+include SolidRuby
+
+def filleted_cube
+  edges = [:top, :bottom, :left, :right]
+  faces = [:top, :bottom, :left, :right, :front, :back]
+
+  res = nil
+  x = 0
+  y = 0
+
+  faces.each do |f|
+    edges.each do |e|
+      res += cube(x: 5, y: 5, z: 10).fillet({f => e, :r => 1})
+        .translate(x: x, y: y)
+
+        y += 10
+    end
+
+    x += 10
+    y = 0
+  end
+
+  res += cube(x: 5, y: 5, z: 10)
+    .fillet(edges: :vertical, r: 1)
+    .translate(x: -10)
+
+  res += cube(x: 5, y: 5, z: 10)
+    .fillet(edges: :horizontal, r: 1)
+    .translate(x: -10, y: 10)
+
+  res += cube(x: 5, y: 5, z: 10)
+    .fillet(edges: :all, r: 1)
+    .translate(x: -10, y: 20)
+end
+
+filleted_cube.save('filleted_cube.scad')

data/examples/gear.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'solidruby'
+include SolidRuby
+
+g1 = Gear.new(module: 0.5, teeth: 80, bore: 5, height: 4)
+#g2 = Gear.new(module: 0.5, teeth: 14, bore: 5, height: 8)
+
+g1.save('gear.scad')
+# puts g1.distance_to(g2)
+# puts g1.show.scad_output

data/examples/knurls.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'solidruby'
+include SolidRuby
+
+res = knurled_cube([41, 10, 4])
+# Total rendering time: 0 hours, 5 minutes, 53 seconds
+
+# Total rendering time: 0 hours, 1 minutes, 41 seconds
+
+# res = knurled_cylinder(d:16,h:10)
+
+res.save('knurls.scad', '$fn=64;')

data/examples/nut_support.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'solidruby'
+include SolidRuby
+
+res = cube([160, 20, 20]).center_y.translate(x: -5)
+[2.5, 3, 4, 5, 6, 8, 10, 12].each do |size|
+  b = Bolt.new(size, 40)
+  n = Nut.new(size)
+  res -= b.output
+  res -= n.output
+  res += n.add_support(0.2)
+
+  res.translate(x: -20)
+end
+
+res.save('nut_support.scad', '$fn=64;')

data/examples/openscad_examples/old/example001.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'solidruby'
+include SolidRuby
+
+size = 50
+hole = 25
+h = size * 2.5
+
+res = sphere(d: size)
+res -= cylinder(d: hole, h: h, center: true)
+res -= cylinder(d: hole, h: h, center: true).rotate(x: 90)
+res -= cylinder(d: hole, h: h, center: true).rotate(y: 90)
+
+res.save('example001.scad')
+
+# module example001()
+# {
+#   function r_from_dia(d) = d / 2;
+# 
+#   module rotcy(rot, r, h) {
+#     rotate(90, rot)
+#       cylinder(r = r, h = h, center = true);
+#   }
+#
+#   difference() {
+#     sphere(r = r_from_dia(size));
+#     rotcy([0, 0, 0], cy_r, cy_h);
+#     rotcy([1, 0, 0], cy_r, cy_h);
+#     rotcy([0, 1, 0], cy_r, cy_h);
+#   }
+#
+#   size = 50;
+#   hole = 25;
+#
+#   cy_r = r_from_dia(hole);
+#   cy_h = r_from_dia(size * 2.5);
+# }
+#
+# echo(version=version());
+#
+# example001();

data/examples/openscad_examples/old/example002.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'solidruby'
+include SolidRuby
+
+# note that center:true doesn't work with cube
+# however, there are convenience methods like
+# center, center_x, center_y, center_xy, center_z available.
+# As rule of thumb, avoid center if possible.
+
+res1 = cube([30, 30, 30]).center
+res1 += cube([15, 15, 50]).center.translate(z: -25)
+
+res2 = cube([50, 10, 10]).center
+res2 += cube([10, 50, 10]).center
+res2 += cube([10, 10, 50]).center
+
+res = res1 - res2
+res *= cylinder(r1: 20, r2: 5, h: 50, center: true).translate(z: 5)
+
+res.save('example002.scad')
+
+# module example002()
+# {
+#   intersection() {
+#     difference() {
+#       union() {
+#         cube([30, 30, 30], center = true);
+#         translate([0, 0, -25])
+#           cube([15, 15, 50], center = true);
+#       }
+#       union() {
+#         cube([50, 10, 10], center = true);
+#         cube([10, 50, 10], center = true);
+#         cube([10, 10, 50], center = true);
+#       }
+#     }
+#     translate([0, 0, 5])
+#       cylinder(h = 50, r1 = 20, r2 = 5, center = true);
+#   }
+# }
+#
+# echo(version=version());
+#
+# example002();