ruby-gdsii 1.0.0

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,23 @@
+require 'rubygems'
+
+SPEC = Gem::Specification.new do |s|
+  s.name     = "ruby-gdsii"
+  s.version  = "1.0.0"
+  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}/**/*")
+  s.files    = candidates.delete_if do |item|
+                 item.include?("CVS") || item.include?("rdoc")
+               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
+

data/test/h_write.rb

@@ -0,0 +1,117 @@
+##############################################################################
+#
+# == write.rb
+#
+# Tests the capabilities of writing GDSII using the high-level group objects.
+# This test should cover most of the capabilities of the high-level GDSII
+# methods.
+#
+# === Author
+#
+# James D. Masters (james.d.masters@gmail.com)
+#
+##############################################################################
+
+require 'time'
+require 'gdsii'
+
+include Gdsii
+
+
+# Get arguments / show usage...
+unless (out_file = ARGV[0])
+  abort "
+Uses high-level GDSII methods to write out a number of GDSII records using
+many of the available method calls.  This can be useful to verify that the
+GDSII library is working and the output file can be compared against the
+file found in ./test/baseline/h_write.gds to ensure that the platform is
+reading and writing GDSII properly.
+
+Usage: h_write.rb <out-file>
+
+"
+end
+
+
+# Get a standard time (epoch; 12/31/1969) so we have the same time stamp for
+# comparing GDSII output
+time = Time.utc(2000, 1, 1, 0, 0, 0)
+
+# Create a new GDSII library
+lib = Library.new('MYLIB.DB')
+lib.modify_time = time
+lib.access_time = time
+
+# Create a top level structure
+top = Structure.new('top')
+top.create_time = time
+top.modify_time = time
+
+# Create a box 5u square on layer 1:0 with the center at the origin
+Boundary.new(1, 0, [-2500,-2500, -2500,2500, 2500,2500, 2500,-2500, -2500,-2500]) do |bnd|
+  bnd.add Property.new(1, 'testprop1')
+  bnd.add Property.new(1, 'testprop2')
+  bnd.add Property.new(2, 'testprop3')
+  top.add bnd
+end
+
+# Create text labels around the 5u box using different text label origins
+top.add Text.new(1, 0, [0,0],         'c',  0, :c )
+top.add Text.new(1, 0, [0,2500],      'n',  0, :n )
+top.add Text.new(1, 0, [2500,2500],   'ne', 0, :ne)
+top.add Text.new(1, 0, [2500,0],      'e',  0, :e )
+top.add Text.new(1, 0, [2500,-2500],  'se', 0, :se)
+top.add Text.new(1, 0, [0,-2500],     's',  0, :s )
+top.add Text.new(1, 0, [-2500,-2500], 'sw', 0, :sw)
+top.add Text.new(1, 0, [-2500,0],     'w',  0, :w )
+top.add Text.new(1, 0, [-2500,2500],  'nw', 0, :nw)
+
+# Test different fonts
+0.upto(3) do |font|
+  top.add Text.new(1, 0, [0, -500*font-3000], "font#{font}", font)
+end
+
+# Create a via/contact structure
+via = Structure.new('via')
+via.create_time = time
+via.modify_time = time
+
+lib.add via
+via.add Boundary.new(1, 0, [-500,-500, -500,500, 500,500, 500,-500, -500,-500])
+via.add Boundary.new(2, 0, [-800,-800, -800,800, 800,800, 800,-800, -800,-800])
+via.add Boundary.new(3, 0, [-600,-600, -600,600, 600,600, 600,-600, -600,-600])
+
+# Create a transistor structure - use our via cell for gate and source/drain
+# terminals
+lib.add trans = Structure.new('trans')
+trans.create_time = time
+trans.modify_time = time
+
+trans.add Boundary.new(1, 0, [-2500,-5000, -2500,5000, 2500,5000, 2500,-5000, -2500,-5000])
+trans.add Path.new(4, 0, 0, 800, [0,-7000, 0,7000])
+trans.add SRef.new('via', [-1700,0])
+trans.add SRef.new('via', [1700,0])
+trans.add SRef.new('via', [0,7000])
+
+# Drop transistor cell down every 1.5u using different rotations and flip/x
+x_offset = 0
+[false, true].each do |reflect_x|
+  0.step(270, 90) do |angle|
+    # Create an sref with the reflection and angle
+    SRef.new('trans', [x_offset, 12000]) do |sref|
+      sref.strans.reflect_x = reflect_x
+      sref.strans.angle = angle.to_f
+      top.add sref
+    end
+
+    # Add annotation text indicating reflection and angle
+    top.add Text.new(1, 0, [x_offset, 20000], "reflect_x=#{reflect_x}", 0, :c)
+    top.add Text.new(1, 0, [x_offset, 20500], "angle=#{angle.to_f.to_s}", 0, :c)
+             
+    x_offset += 15000
+  end
+end
+
+# Write the library to file
+lib.add top
+lib.write(out_file)