jfreeze-ruby-gdsii 1.0.1

data/lib/gdsii/text.rb

@@ -0,0 +1,203 @@
+require 'gdsii/group'
+require 'gdsii/strans'
+require 'gdsii/element'
+
+module Gdsii
+  
+  #
+  # Represents a GDSII Text element.  Most methods are from Element or from the
+  # various included Access module methods.
+  #
+  class Text < Element
+    
+    # Include various record accessors
+    include Access::Layer
+    include Access::XY
+    include Access::PathType
+    include Access::Width
+    include Access::ELFlags
+    include Access::Plex
+    include Access::StransGroup
+    
+    #
+    # Text BNF description:
+    #
+    #  <text> ::= TEXT [ELFLAGS] [PLEX] LAYER TEXTTYPE [PRESENTATION]
+    #             [PATHTYPE] [WIDTH] [<strans>] XY STRING
+    #
+    self.bnf_spec = BnfSpec.new(
+      BnfItem.new(GRT_TEXT),
+      BnfItem.new(GRT_ELFLAGS, true),
+      BnfItem.new(GRT_PLEX, true),
+      BnfItem.new(GRT_LAYER),
+      BnfItem.new(GRT_TEXTTYPE),
+      BnfItem.new(GRT_PRESENTATION, true),
+      BnfItem.new(GRT_PATHTYPE, true),
+      BnfItem.new(GRT_WIDTH, true),
+      BnfItem.new(Strans, true),
+      BnfItem.new(GRT_XY),
+      BnfItem.new(GRT_STRING),
+      BnfItem.new(Properties, true),
+      BnfItem.new(GRT_ENDEL)
+    )
+
+    #
+    # Create a simple hash to store compass points and their respective
+    # presentation values and vice-versa.  This is used in manipulating
+    # and querying the text's PRESENTATION record.
+    #
+    @@pres_lookup = {
+      # * bits 0 and 1: x origin; 00 left, 01 center, 10 right
+      # * bits 2 and 3: y origin; 00 top, 01, center, 10 bottom
+      [0b0000, 0b0000] => :nw,
+      [0b0000, 0b0100] => :w,
+      [0b0000, 0b1000] => :sw,
+      [0b0001, 0b0000] => :n,
+      [0b0001, 0b0100] => :c,
+      [0b0001, 0b1000] => :s,
+      [0b0010, 0b0000] => :ne,
+      [0b0010, 0b0100] => :e,
+      [0b0010, 0b1000] => :se
+    }
+    @@pres_lookup.merge!(@@pres_lookup.invert)
+    
+    #
+    # Create a text record grouping given a layer, text type, xy coordinate,
+    # and a string.
+    #
+    #  text1 = Gdsii::Text.new(1, 0, [0,0], 'hello')
+    #  text2 = Gdsii::Text.new(1, 0, [100, 0], 'world', 2, :ne)
+    #
+    def initialize(layer=nil, texttype=nil, xy=nil, string=nil, font=nil, origin=nil)
+      super()
+      @records[GRT_TEXT] = Record.new(GRT_TEXT)
+      self.layer = layer unless layer.nil?
+      self.texttype = texttype unless texttype.nil?
+      self.xy = xy unless xy.nil?
+      self.string = string unless string.nil?
+      self.font = font unless font.nil?
+      self.origin = origin unless origin.nil?
+      yield self if block_given?
+    end
+
+    #
+    # Get the texttype record (returns Record).
+    #
+    def texttype_record() @records.get(GRT_TEXTTYPE); end
+
+    #
+    # Get the texttype number (returns Fixnum).
+    #
+    def texttype() @records.get_data(GRT_TEXTTYPE); end
+  
+    #
+    # Set the texttype number.
+    #
+    def texttype=(val) @records.set(GRT_TEXTTYPE, val); end
+
+    #
+    # Get the text string record (returns Record).
+    #
+    def string_record() @records.get(GRT_STRING); end
+
+    #
+    # Get the text string value (returns String).
+    #
+    def string() @records.get_data(GRT_STRING); end
+  
+    #
+    # Set the text string value.
+    #
+    def string=(val) @records.set(GRT_STRING, val); end
+ 
+    #
+    # Get the presentation record (returns Record).
+    #
+    def presentation_record() @records.get(GRT_PRESENTATION); end
+
+    #
+    # Get the presentation bitarray number (returns Fixnum).  It is probably
+    # easier to use #font and #origin instead.
+    #
+    def presentation() @records.get_data(GRT_PRESENTATION); end
+  
+    #
+    # Set the presentation bitarray number.  It is easier to not modify
+    # this number directly but to use #font= and #origin= instead.
+    #
+    # * bits 0 and 1: x origin; 00 left, 01 center, 10 right
+    # * bits 2 and 3: y origin; 00 top, 01, center, 10 bottom
+    # * bits 4 and 5: font number; 00 font 0, 01 font 1, 10 font 2, 11 font 3
+    # * All other bits are reserved
+    #
+    def presentation=(val)
+      @records.set(GRT_PRESENTATION, val);
+    end
+
+    #
+    # Specifies the font to use (valid range is 0-3).  Calls #presentation=
+    # to change the font bits.
+    #
+    def font=(val)
+      if val >= 0 and val <= 3
+        # Be sure to clear out old value first...
+        # start at 4th bit; 2**4 == 16
+        pres = presentation || 0
+        self.presentation = (pres & 0xFFCF) | 16*val
+      else
+        raise ArgumentError, "Font value must be 0-3; given: #{val}"
+      end
+    end
+
+    #
+    # Returns the font number (Fixnum in range 0-3) according to the font bits
+    # in the #presentation record.
+    #
+    def font()
+      # clear all other bits then start at 4th bit; 2**4 == 16
+      pres = presentation || 0
+      (pres & 0x0030) / 16
+    end
+
+    #
+    # Returns the text origin as a symbol containing one of 9 possible
+    # values representing compass points:
+    #
+    # * :c == center (x == center; y == center)
+    # * :n == north (x == center; y == top)
+    # * :ne == northeast (x == right; y == top)
+    # * :e == east (x == right; y == center)
+    # * :se == southeast (x == right; y == bottom)
+    # * :s == south (x == center; y == bottom)
+    # * :sw == southwest (x == left; y == bottom)
+    # * :w == west (x == left; y == center)
+    # * :nw == northwest (x == left; y == top)
+    #
+    # The #presentation method is used to extract the bits related to the
+    # text origin.
+    #
+    def origin()
+      # origin bits: x == 0-1; y == 2-3
+      pres = presentation || 0
+      x_num = (pres & 0b0011)
+      y_num = (pres & 0b1100)
+      @@pres_lookup[[x_num, y_num]]
+    end
+
+    #
+    # Sets the text origin based upon one of 9 compass points (see
+    # #origin for the list).  The #presentation= method is called to manipulate
+    # the presentation bits related to the text origin.
+    #
+    def origin=(point)
+      if nums = @@pres_lookup[point]
+        # clear origin bits then set to the new value
+        pres = presentation || 0
+        self.presentation = (pres & 0xFFF0) | nums[0] | nums[1]
+      else
+        raise "Compass point given: #{point.inspect} is not valid"
+      end
+    end
+    
+  end
+end

data/pkg/ruby-gdsii.gem

@@ -0,0 +1,46 @@
+SPEC = Gem::Specification.new do |s|
+  s.name     = "ruby-gdsii"
+  s.version  = "1.0.1"
+  s.author   = "James Masters, Jim Freeze, et al"
+  s.email    = "james.d.masters@intel.com"
+  s.homepage = "http://rubyforge.org/frs/?group_id=833"
+  s.platform = Gem::Platform::RUBY
+  #s.rubyforge_project = 'ruby-gdsii'
+  s.summary  = "GDSII reader and writer with both high-level (easier to use) and low-level (faster performance) methods."
+  s.executables = %w(rgds-debug rgds-dump rgds-join rgds-layers rgds-sremove rgds-ssplit rgds-stats rgds-structs rgds-tree rgds2rb)
+#  candidates = Dir.glob("{bin,lib,pkg,samples,test}/**/*")
+  candidates = []
+  candidates.concat %w(bin/rgds-debug bin/rgds-dump bin/rgds-join bin/rgds-layers bin/rgds-sremove bin/rgds-ssplit)
+  candidates.concat %w(bin/rgds-stats bin/rgds-structs bin/rgds-tree bin/rgds2rb)
+  
+  candidates.concat %w(lib/gdsii/aref.rb lib/gdsii/bnf.rb lib/gdsii/boundary.rb lib/gdsii/box.rb lib/gdsii/byte_order.rb)
+  candidates.concat %w(lib/gdsii/element.rb lib/gdsii/group.rb lib/gdsii/library.rb lib/gdsii/mixins.rb lib/gdsii/node.rb)
+  candidates.concat %w(lib/gdsii/path.rb lib/gdsii/property.rb lib/gdsii/record lib/gdsii/record/consts.rb)
+  
+  candidates.concat %w(lib/gdsii/record/datatypes/ascii.rb lib/gdsii/record/datatypes/bitarray.rb)
+  candidates.concat %w(lib/gdsii/record/datatypes/data.rb lib/gdsii/record/datatypes/int2.rb)
+  candidates.concat %w(lib/gdsii/record/datatypes/int4.rb lib/gdsii/record/datatypes/nodata.rb)
+  candidates.concat %w(lib/gdsii/record/datatypes/real4.rb lib/gdsii/record/datatypes/real8.rb)
+  candidates.concat %w(lib/gdsii/record.rb lib/gdsii/sref.rb lib/gdsii/strans.rb lib/gdsii/structure.rb)
+  candidates.concat %w(lib/gdsii/text.rb lib/gdsii.rb)
+  
+  candidates.concat %w(pkg/ruby-gdsii.gem )
+  
+  candidates.concat %w(samples/hello.gds samples/hello.out.rb samples/hello.rb)
+  
+  candidates.concat %w(test/baseline/dcp1.gds test/baseline/h_write.gds test/h_pthru.rb)
+  candidates.concat %w(test/h_write.rb test/hs_pthru.rb test/l_pthru.rb test/test_gds_group.rb)
+  candidates.concat %w(test/test_gds_record.rb)
+  candidates << "Rakefile"
+  candidates << "CHANGELOG.txt"
+  s.files    = candidates.delete_if do |item|
+                 item.include?("CVS") || item.include?("rdoc") || item.include?(".git")
+               end
+  #s.require_path = "lib"
+  s.test_files   = ["test/test_gds_group.rb", "test/test_gds_record.rb"]
+  s.bindir       = "bin"
+  s.has_rdoc     = true
+  s.extra_rdoc_files = ["README.txt", "LICENSE.txt"]
+end
+
+

data/samples/hello.out.rb

@@ -0,0 +1,84 @@
+require 'gdsii'
+
+File.open('hello.out', 'wb') do |outf|
+
+  Gdsii::Record.new(Gdsii::GRT_HEADER, 5).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_BGNLIB, [108, 12, 4, 14, 51, 0, 108, 12, 4, 14, 51, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_LIBNAME, "HELLO.DB").write(outf)
+  Gdsii::Record.new(Gdsii::GRT_UNITS, [0.001, 1.0e-09]).write(outf)
+
+  ############################################################################
+  # STRUCTURE: hello
+  ############################################################################
+
+  Gdsii::Record.new(Gdsii::GRT_BGNSTR, [108, 12, 4, 14, 51, 0, 108, 12, 4, 14, 51, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_STRNAME, "hello").write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_BOUNDARY, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_LAYER, 1).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_DATATYPE, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [0, 0, 0, 700, 100, 700, 100, 400, 300, 400, 300, 700, 400, 700, 400, 0, 300, 0, 300, 300, 100, 300, 100, 0, 0, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_BOUNDARY, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_LAYER, 1).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_DATATYPE, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [600, 0, 600, 700, 900, 700, 900, 600, 700, 600, 700, 400, 900, 400, 900, 300, 700, 300, 700, 100, 900, 100, 900, 0, 600, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_BOUNDARY, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_LAYER, 1).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_DATATYPE, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [1100, 0, 1100, 700, 1200, 700, 1200, 100, 1400, 100, 1400, 0, 1100, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_BOUNDARY, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_LAYER, 1).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_DATATYPE, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [1600, 0, 1600, 700, 1700, 700, 1700, 100, 1900, 100, 1900, 0, 1600, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_BOUNDARY, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_LAYER, 1).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_DATATYPE, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [2100, 200, 2100, 600, 2200, 700, 2500, 700, 2600, 600, 2600, 100, 2500, 0, 2200, 0, 2100, 100, 2100, 200, 2200, 200, 2300, 100, 2400, 100, 2500, 200, 2500, 500, 2400, 600, 2300, 600, 2200, 500, 2200, 200, 2100, 200]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_ENDSTR, nil).write(outf)
+
+  ############################################################################
+  # STRUCTURE: top
+  ############################################################################
+
+  Gdsii::Record.new(Gdsii::GRT_BGNSTR, [108, 12, 4, 14, 51, 0, 108, 12, 4, 14, 51, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_STRNAME, "top").write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SREF, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SNAME, "hello").write(outf)
+  Gdsii::Record.new(Gdsii::GRT_STRANS, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ANGLE, 0.0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [0, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SREF, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SNAME, "hello").write(outf)
+  Gdsii::Record.new(Gdsii::GRT_STRANS, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ANGLE, 90.0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [0, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SREF, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SNAME, "hello").write(outf)
+  Gdsii::Record.new(Gdsii::GRT_STRANS, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ANGLE, 180.0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [0, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SREF, nil).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_SNAME, "hello").write(outf)
+  Gdsii::Record.new(Gdsii::GRT_STRANS, 0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ANGLE, 270.0).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_XY, [0, 0]).write(outf)
+  Gdsii::Record.new(Gdsii::GRT_ENDEL, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_ENDSTR, nil).write(outf)
+
+  Gdsii::Record.new(Gdsii::GRT_ENDLIB, nil).write(outf)
+
+end

data/samples/hello.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+##############################################################################
+#
+# == hello.rb
+#
+# A simple "Hello World" example of the high-level GDSII classes and method
+# calls.  This example will display the words "Hello" in a subcell of four
+# different rotations about the (0,0) origin.
+#
+# === Author
+#
+# James D. Masters (james.d.masters@gmail.com)
+#
+# === History
+#
+# * 03/27/2007 (jdm): Initial version
+#
+#
+##############################################################################
+
+
+require 'gdsii/record.rb'
+include Gdsii
+
+
+
+require 'gdsii'
+
+include Gdsii
+
+lib = Library.new('HELLO.DB')
+
+
+########################################
+# Write "HELLO" in a structure on layer 1,0
+########################################
+
+# create hello structure and add to GDSII library
+hello = lib.add Structure.new('hello')
+
+# "H"
+hello.add(Boundary.new(1, 0, [    0,   0,        0,  700,
+                                100,  700,     100,  400,
+                                300,  400,     300,  700,
+                                400,  700,     400,    0,
+                                300,    0,     300,  300,
+                                100,  300,     100,    0,
+                                  0,    0               ]))
+
+# "E"
+hello.add(Boundary.new(1, 0, [ 600,    0,     600,  700,
+                               900,  700,     900,  600,
+                               700,  600,     700,  400,
+                               900,  400,     900,  300,
+                               700,  300,     700,  100,
+                               900,  100,     900,    0,
+                               600,    0               ]))
+
+# "L"
+hello.add(Boundary.new(1, 0, [1100,    0,    1100,  700,
+                              1200,  700,    1200,  100,
+                              1400,  100,    1400,    0,
+                              1100,    0               ]))
+
+# "L"
+hello.add(Boundary.new(1, 0, [1600,    0,    1600,  700,
+                              1700,  700,    1700,  100,
+                              1900,  100,    1900,    0,
+                              1600,    0               ]))
+
+# "O"
+hello.add(Boundary.new(1, 0, [2100,  200,    2100,  600,
+                              2200,  700,    2500,  700,
+                              2600,  600,    2600,  100,
+                              2500,    0,    2200,    0,
+                              2100,  100,    2100,  200,
+                              2200,  200,    2300,  100,
+                              2400,  100,    2500,  200,
+                              2500,  500,    2400,  600,
+                              2300,  600,    2200,  500,
+                              2200,  200,    2100,  200]))
+
+# Create a top structure and add 4 instantiations of rotation for structure
+# "hello"
+top = lib.add Structure.new('top')
+
+0.step(270, 90) do |angle|
+  top.add SRef.new('hello', [0,0]).configure {|sref|
+    sref.strans.angle = angle.to_f
+  }
+end
+
+lib.write('hello.gds')
+

data/test/h_pthru.rb

@@ -0,0 +1,22 @@
+require 'gdsii'
+include Gdsii
+
+in_file, out_file = ARGV
+unless in_file and out_file
+  abort "
+Uses the GDSII high-level methods to read in a GDSII file and then write out
+the same GDSII file.  The file should be identical - or at least just have
+just EOF null-padding differences.
+
+h_pthru.rb <in-file> <out-file>
+
+"
+end
+
+File.open(in_file, 'rb') do |inf|
+  puts "Reading #{in_file}..."
+  lib = Library.read(inf)
+  puts "Writing #{out_file}..."
+  lib.write(out_file)
+end
+