siren2 0.1.2

data/lib/io/dxf.rb

@@ -0,0 +1,68 @@
+#
+# AutoCAD DXF file I/O method
+#
+module Siren
+
+  def self.save_dxf(shape, path, deflect = 1.0, angle = 5.0.to_rad)
+    File.open(path, "w") do |f|
+      @ff = f
+      def self.w(code, data)
+        @ff.write "% 3d\n#{data}\n" % [code]
+      end
+      def self.wp(pt, ofs = 0)
+        w 10 + ofs, pt.x
+        w 20 + ofs, pt.y
+        w 30 + ofs, pt.z
+      end
+      w 0, "SECTION"
+      w 2, "ENTITIES"
+      shape.vertices(Siren::Edge).each do |e|
+        w 0, "POINT"
+        w 8, "0"
+        wp e.xyz
+      end
+      shape.edges(Siren::Face).each do |e|
+        ps = e.to_pts(deflect)
+        if ps.size == 2
+          w 0, "LINE"
+          w 8, "0"
+          wp ps.first
+          wp ps.last, 1
+        else
+          w 0, "POLYLINE"
+          wp [0, 0, 0]
+          w 8, "0"
+          w 66, 1
+          w 70, 8 # 3D=8,2D=0
+          ps.each do |pt|
+            w 0, "VERTEX"
+            w 8, "0"
+            wp pt
+          end
+          w 0, "SEQEND"
+        end
+      end
+      shape.faces.each do |face|
+        face.triangle(deflect, angle).each do |m|
+          w 0, "3DFACE"
+          w 8, "0"
+          mm = m[0,3]
+          wp mm[0]
+          wp mm[1], 1
+          wp mm[2], 2
+          wp mm[0], 3
+          w 70, 8
+        end
+      end
+      w 0, "ENDSEC"
+      w 0, "EOF"
+    end
+    nil
+  end
+
+  def save_dxf(*args)
+    Siren.save_dxf(*args)
+  end
+
+end
+

data/lib/io/plot.rb

@@ -0,0 +1,38 @@
+#
+# Gnuplot data file I/O method
+#
+module Siren
+
+  def self.save_plot(shape, path, face_mode = false, deflect = 1.0, angle = 5.0.to_rad)
+    File.open(path, "w") do |f|
+      f.puts "# Created by siren - http://siren.xyz/"
+      if face_mode
+        shape.faces.map {|e|
+          e.triangle(deflect, angle).map {|m|
+            m[0,3]
+          }
+        }.flatten(1).each do |m|
+          f.puts "%.f %.f %.f" % m[0]
+          f.puts "%.f %.f %.f" % m[1]
+          f.puts "%.f %.f %.f" % m[2]
+          f.puts ""
+        end
+      else
+        # Curve mode
+        shape.edges.each do |e|
+          e.to_pts(deflect).each do |pos|
+            f.puts "%.f %.f %.f" % pos
+          end
+          f.puts ""
+        end
+      end
+    end
+    nil
+  end
+
+  def save_plot(*args)
+    Siren.save_plot(*args)
+  end
+
+end
+

data/lib/io/ply.rb

@@ -0,0 +1,57 @@
+#
+# Stanford PLY file I/O method
+#
+module Siren
+
+  def self.save_ply(shape, path, deflect = 1.0, angle = 5.0.to_rad)
+    File.open(path, "w") do |f|
+      fs = shape.faces.map {|e|
+        e.triangle(deflect, angle).map {|m|
+          m[0,3]
+        }
+      }.flatten(1)
+      es = shape.edges(Siren::Face).map{|e|
+        e.to_pts(deflect)
+      }
+      vs = [fs, es].flatten(2).sort.uniq
+      f.puts "ply"
+      f.puts "format ascii 1.0"
+      f.puts "comment Created by siren - http://siren.xyz/"
+      if vs.size > 0
+        f.puts "element vertex %d" % vs.size
+        f.puts "property float x"
+        f.puts "property float y"
+        f.puts "property float z"
+      end
+      if es.size > 0
+        f.puts "element edge %d" % es.size
+        f.puts "property uint vertex1"
+        f.puts "property uint vertex2"
+      end
+      if fs.size > 0
+        f.puts "element face %d" % fs.size
+        f.puts "property list uchar uint vertex_indices"
+      end
+      f.puts "end_header"
+      vs.each do |e|
+        f.puts "%.f %.f %.f" % e
+      end
+      es.each do |e|
+        sp = vs.index(e.first)
+        tp = vs.index(e.last)
+        f.puts "%d %d" % [sp, tp]
+      end
+      fs.each do |e|
+        pts = e.map{|m| vs.index(m)}
+        f.puts pts.size.to_s + " " + pts.join(" ")
+      end
+      nil
+    end
+  end
+
+  def save_ply(*args)
+    Siren.save_ply(*args)
+  end
+
+end
+

data/lib/io/stl.rb

@@ -0,0 +1,35 @@
+#
+# STL file I/O method
+#
+
+module Siren
+
+  def self.save_stl(shape, path, ascii = true, deflect = 1.0, angle = 5.0.to_rad)
+    File.open(path, "w") do |f|
+      if ascii
+        f.write "solid shape, STL ascii file built with siren. http://siren.xyz/\n"
+        shape.faces.each do |face|
+          face.triangle(deflect, angle).each do |mesh|
+            f.write "facet normal %8e %8e %8e\n" % mesh[5]
+            f.write "  outer loop\n"
+            f.write "    vertex %8e %8e %8e\n" % mesh[0]
+            f.write "    vertex %8e %8e %8e\n" % mesh[1]
+            f.write "    vertex %8e %8e %8e\n" % mesh[2]
+            f.write "  endloop\n"
+            f.write "endfacet\n"
+          end
+        end
+        f.write "endsolid shape\n"
+      else
+        raise NotImplementedError
+      end
+    end
+    nil
+  end
+
+  def save_stl(*args)
+    Siren.save_stl(*args)
+  end
+
+end
+

data/lib/io/svg.rb

@@ -0,0 +1,44 @@
+#
+# SVG file I/O method
+#
+
+module Siren
+
+  def self.save_svg(shape, path, deflect = 1.0, angle = 5.0.to_rad)
+    File.open(path, "w") do |f|
+      df = 0.5 # Depth factor
+      header = <<-EOF
+<?xml version='1.0' encoding='utf-8'?>
+<!-- This SVG file built with siren. http://siren.xyz/ -->
+<svg xmlns='http://www.w3.org/2000/svg'>
+  <defs>
+    <style type='text/css'><![CDATA[
+      path {
+        fill: none;
+        stroke: black;
+        stroke-width: 1;
+      }
+    ]]></style>
+  </defs>
+  <g transform="matrix(1,0,0,1,0,0)">
+      EOF
+      f.write header
+      shape.edges.each do |edge|
+        pts = edge.to_pts(deflect)
+        sp = pts.shift
+        d = "M#{sp.y + sp.x * df},#{sp.z + sp.x * df}"
+        pts.each {|pt| d << "L#{pt.y + pt.x * df},#{pt.z + pt.x * df}" }
+        f.write "    <path d='#{d}' />\n"
+      end
+      f.write "  </g>\n"
+      f.write "</svg>\n"
+    end
+    nil
+  end
+
+  def save_svg(*args)
+    Siren.save_svg(*args)
+  end
+
+end
+

data/lib/kernel/array.rb

@@ -0,0 +1,133 @@
+#
+# Array クラス拡張メソッド
+#
+class Array
+
+  def to_v
+    Siren::Vec.new self
+  end
+
+  def to(other)
+    other.to_v - self.to_v
+  end
+
+  def from(other)
+    self.to_v - other.to_v
+  end
+
+  def xyz
+    self[0,3]
+  end
+
+  def xyz=(val)
+    self[0,3] = val
+  end
+
+  def dist(other)
+    (self.to_v - other.to_v).magnitude
+  end
+
+  def center(other)
+    ((self.to_v + other.to_v) / 2.0).xyz
+  end
+
+  def equal?(other, lintol)
+    dist(other) < lintol
+  end
+
+  def translate(t)
+    if t.is_a? Siren::Vec
+      v = t
+    else
+      v = t.to_v
+    end
+    (self.to_v + v).xyz
+  end
+
+  def translate!(t)
+    self.xyz = translate(t)
+  end
+
+  def rotate(op, dir, angle)
+    self.from(op).rotate(dir, angle).xyz.translate(op).xyz
+  end
+
+  def rotate!(op, dir, angle)
+    self.xyz = rotate(op, dir, angle)
+  end
+
+  def scale(op, f)
+    if (op.equal?(self, 1.0e-7))
+      self.xyz
+    else
+      (self.from(op).normal * f).xyz.translate(op).xyz
+    end
+  end
+
+  def scale!(op, f)
+    self.xyz = scale(op, f)
+  end
+
+  def mirror(op, dir = Siren::Vec.zero)
+    if dir == Siren::Vec.zero
+      op.translate(self.to(op)).xyz
+    else
+      self.from(op).mirror(dir).xyz.translate(op).xyz
+    end
+  end
+
+  def mirror!(op, dir = Siren::Vec.zero)
+    self.xyz = mirror(op, dir)
+  end
+
+  def trans(t)
+    t.move_point self
+  end
+
+  def trans!(t)
+    r = t.move_point self
+    self.xyz = r.xyz
+  end
+
+  def x
+    val = (self[0] ||= 0.0)
+    if val.is_a?(Float)
+      val
+    elsif val.is_a?(Numeric)
+      val.to_f
+    else
+      0.0
+    end
+  end
+
+  def y
+    val = (self[1] ||= 0.0)
+    if val.is_a?(Float)
+      val
+    elsif val.is_a?(Numeric)
+      val.to_f
+    else
+      0.0
+    end
+  end
+
+  def z
+    val = (self[2] ||= 0.0)
+    if val.is_a?(Float)
+      val
+    elsif val.is_a?(Numeric)
+      val.to_f
+    else
+      0.0
+    end
+  end
+
+  def x=(val); self[0] = val end
+  def y=(val); self[1] = val end
+  def z=(val); self[2] = val end
+
+  def self.origin
+    [0, 0, 0]
+  end
+end
+

data/lib/kernel/float.rb

@@ -0,0 +1,15 @@
+#
+# Float クラス拡張メソッド
+#
+class Float
+
+  def to_deg
+    self * 180.0 / Math::PI
+  end
+
+  def to_rad
+    self * Math::PI / 180.0
+  end
+
+end
+

data/lib/shape.rb

@@ -0,0 +1,157 @@
+#
+# Shape クラス拡張メソッド
+#
+class Siren::Shape
+
+  # Explorer wrapper methods
+
+  def compounds(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Compound)
+    else
+      self.explore(Siren::Compound, filter)
+    end
+  end
+
+  def solids(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Solid)
+    else
+      self.explore(Siren::Solid, filter)
+    end
+  end
+
+  def shells(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Shell)
+    else
+      self.explore(Siren::Shell, filter)
+    end
+  end
+
+  def faces(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Face)
+    else
+      self.explore(Siren::Face, filter)
+    end
+  end
+
+  def wires(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Wire)
+    else
+      self.explore(Siren::Wire, filter)
+    end
+  end
+
+  def edges(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Edge)
+    else
+      self.explore(Siren::Edge, filter)
+    end
+  end
+
+  def vertices(filter = nil)
+    if filter.nil?
+      self.explore(Siren::Vertex)
+    else
+      self.explore(Siren::Vertex, filter)
+    end
+  end
+
+  # Type check methods
+
+  def compound?
+    self.is_a? Siren::Compound
+  end
+
+  def solid?
+    self.is_a? Siren::Solid
+  end
+
+  def shell?
+    self.is_a? Siren::Shell
+  end
+
+  def face?
+    self.is_a? Siren::Face
+  end
+
+  def wire?
+    self.is_a? Siren::Wire
+  end
+
+  def edge?
+    self.is_a? Siren::Edge
+  end
+
+  def vertex?
+    self.is_a? Siren::Vertex
+  end
+
+  def dump_tree(current_depth = 0, &limit)
+    hc = sprintf("%06X", self.hashcode(0xFFFFFF))
+    type = self.class.to_s
+    puts "  " * current_depth + "%s:0x%s" % [type, hc]
+    if limit && limit.call(current_depth, self)
+      # puts "  " * current_depth + "..."
+      return
+    end
+    current_depth += 1
+    self.subshapes.each do |s|
+      s.dump_tree(current_depth, &limit)
+    end
+    nil
+  end
+
+  def dump_compound
+    self.dump_tree{|depth, child| child.compound?}
+  end
+
+  def dump_solid
+    self.dump_tree{|depth, child| child.solid?}
+  end
+
+  def dump_shell
+    self.dump_tree{|depth, child| child.sell?}
+  end
+
+  def dump_face
+    self.dump_tree{|depth, child| child.face?}
+  end
+
+  def dump_wire
+    self.dump_tree{|depth, child| child.wire?}
+  end
+
+  def dump_edge
+    self.dump_tree{|depth, child| child.edge?}
+  end
+
+  def dump_vertex
+    self.dump_tree{|depth, child| child.vertex?}
+  end
+
+  def clone(copy_geom = true)
+    Siren.copy(self, copy_geom)
+  end
+
+  def to_a
+    if self.compound?
+      ar = []
+      self.subshapes.each do |s|
+        if s.compound?
+          ar << s.to_a
+        else
+          ar.push s
+        end
+      end
+      return ar
+    else
+      return [self]
+    end
+  end
+
+end