palette = RBA::QPalette::new

palette.setColorGroup(RBA::QPalette::Active, 
  RBA::QBrush::new(RBA::QColor::new("#f0f0f0")),   # windowText
  RBA::QBrush::new(RBA::QColor::new("#303030")),   # button
  RBA::QBrush::new(RBA::QColor::new("#505050")),   # light
  RBA::QBrush::new(RBA::QColor::new("#707070")),   # dark
  RBA::QBrush::new(RBA::QColor::new("#909090")),   # mid
  RBA::QBrush::new(RBA::QColor::new("#e0e0e0")),   # text
  RBA::QBrush::new(RBA::QColor::new("#909090")),   # brightText
  RBA::QBrush::new(RBA::QColor::new("#202020")),   # base
  RBA::QBrush::new(RBA::QColor::new("#101010")),   # window
) 

palette.setColorGroup(RBA::QPalette::Inactive, 
  RBA::QBrush::new(RBA::QColor::new("#f0f0f0")),   # windowText
  RBA::QBrush::new(RBA::QColor::new("#303030")),   # button
  RBA::QBrush::new(RBA::QColor::new("#505050")),   # light
  RBA::QBrush::new(RBA::QColor::new("#707070")),   # dark
  RBA::QBrush::new(RBA::QColor::new("#909090")),   # mid
  RBA::QBrush::new(RBA::QColor::new("#e0e0e0")),   # text
  RBA::QBrush::new(RBA::QColor::new("#909090")),   # brightText
  RBA::QBrush::new(RBA::QColor::new("#202020")),   # base
  RBA::QBrush::new(RBA::QColor::new("#101010")),   # window
) 

palette.setColorGroup(RBA::QPalette::Disabled, 
  RBA::QBrush::new(RBA::QColor::new("#808080")),   # windowText
  RBA::QBrush::new(RBA::QColor::new("#303030")),   # button
  RBA::QBrush::new(RBA::QColor::new("#505050")),   # light
  RBA::QBrush::new(RBA::QColor::new("#606060")),   # dark
  RBA::QBrush::new(RBA::QColor::new("#686868")),   # mid
  RBA::QBrush::new(RBA::QColor::new("#707070")),   # text
  RBA::QBrush::new(RBA::QColor::new("#686868")),   # brightText
  RBA::QBrush::new(RBA::QColor::new("#202020")),   # base
  RBA::QBrush::new(RBA::QColor::new("#101010")),   # window
) 

RBA::QApplication::setPalette(palette)

Set the "run on startup" flag and enjoy night mode:

Matthias

the lym File:

module TestMacro1
include RBA
require_relative 'C:\Users\david\KLayout\macros\helper'
# Enter your Ruby code here ..
a=4
b=helper(a)

end

the rb file with a function I want to call

include RBA

def helper( a)
b=a+1
return b
end

The first time I run it after starting Kayout, the helper() function gets called and returns 5.
Now I edit the helper() function to set b=a+10. I save it with the buttons on the top of the left panel, and also
right click on the helper function an click 'refresh'.

When I run TestMacro1.lym (from green triangle with the exclamation point in the editor), helper still sets b=5, not 14 reflecting the change.
I can put break points in helper() and see the b variable be assigned to 5 even though the code says it should be a+10.
If I add another line like 'c=9' before 'return b' in helper, the function just exits and does not create the c variable.

How do we get the editor to save and use the edited version of the files.
This was never a problem back in version 0.24.

I have tried running Klayout as administrator and closing and reopening the macro dev window.
The only thing that works is closing and re-opening Klayout.

Thanks for any help.

Export DIE size of current GDSII file is very easy.
die=input(71,0)
puts die.bbox.width
puts die.bbox.height

but the key issue will be that , I have over 1000 GDSII file. and I need to export that data of each one.

I have the following (shortened) setup:

tp = RBA::TilingProcessor::new
tp.frame = chip
tp.dbu = ly.dbu
tp.threads = threads
tp.tile_size(tile_size, tile_size)

tp.input("COMP", ly, top_cell.cell_index, COMP)
tp.input("Poly2", ly, top_cell.cell_index, Poly2)
tp.input("PMNDMY", ly, top_cell.cell_index, PMNDMY)

tp.var("space_to_COMP", 3.5 / ly.dbu)
tp.var("space_to_Poly2", 1.5 / ly.dbu)

tp.output("to_fill", TilingOperator::new(ly, top_cell, fill_cell.cell_index, fc_box_in_dbu, row_step_in_dbu, column_step_in_dbu, fc_origin_in_dbu))

tp.queue("
var COMP_20um_spacing = COMP.sized(20um).sized(-20um)
var fill_region = _tile & _frame - COMP_20um_spacing.sized(space_to_COMP) - Poly2.sized(space_to_Poly2) - PMNDMY;
_output(to_fill, fill_region)")

I get the following error:

ERROR: Worker thread: Length or area value with unit requires a layout context at line 3, position 36 (..20um).sized(-20um)

Which makes a lot of sense, however since the tiling processor has information about the dbu, shouldn't it be possible to convert the length value?
Or is there another way to supply the layout context?

As a workaround I can supply the constant as a variable like I did for the spacing:

tp.var("um20", 20 / ly.dbu)

Let me know if you need a full reproducible.

Thanks!

I came across this Cadence forum post that describes the functionality I'm trying to achieve:
https://community.cadence.com/cadence_technology_forums/pcb-design/f/allegro-x-apd/52353/degassing-with-apd
Can anyone help me out?

I have a question about the spike of polygon.

It can be deleted by Merge, but I am curious if it can be detected by DRC.
Thanks for your help.

l1 = (1, 0)
l1.width(0.2.um).output('Minimum width', 'some tips here')

So it seems that width checking is automatically for the minimum checking. If I want to check the maximum length, what I find from tutorial is:

l1 = (1, 0)
l1.drc(width < 2.0um).output('Maximum width', 'some tips here')

Am I right?

=================================================================================
For bbox.width, should I just write it as:

l1 = (1, 0)
if l1.data.bbox.width > 50.um
    l1.output('Maximum length', 'some tips here')
end

Is there a simplified way to realise this?

Recently, I am working with pya Module, and I find that it has Path, DPath, Box, DBox classes and so on, all of them are appeared in pairs. But it seems that there is no DRegion class. We can see from this dicussion If we want to merge two polygons created by DPolygon constructor, it is not convenient because we need to transfer DPolygon to Polygon. If we want to transfer between them, normally we need to manually do unit conversion. Besides, as @sekigawa said, it seems that there is no constructor to transfer array[] DPolygon to array[] Polygon, which is also not convenient.

If we can have DRegion class, then there is another question, we know float and integer can be converted to each other. Why not combine Box and DBox classes, the other pairs are same. If this is possible, programming could be much easier I think.

The problem I want to solve is like below:

First, let us make some convention.
1. Horizontal dimension: the width(length) of the taper.
2. Vertical dimension: the height of the taper, and the low-height we call it height_l, the high-height we call it height_h.

Here, we see the layer 118/120, this is a transition layer, normally is used to mark the taper when its height lower than a threshold value. For example, here. the height_l = 0.04 um, the height_h = 0.2 um. The layer 118/120 marks the part height < 0.1 um. The 171/0 layer is a waveguide layer.

Now, the overlap part of transition layer and waveguide layer is a small taper, and what I really to test is that:
1. The length of the this small taper. (Totally no idea)
2. The length of four edges of this small taper could be known is better. (I saw some function to get this in Documents, I just start to learn about this part)
3. The angle of this enclosed taper.(I saw some function to get this in Documents, I just start to learn about this part).

Hope you could give me some advice.

RDL Capture Pad is like the image below.
I need to find the width (53.45um) of the blue layer in the section where the red layer exists. Is there a method that I can use?

I'm looking into the TilingProcessor feature and came along your example:

layout = ... # the layout
cell = ... # the top cell's index
layout = ... # the input layer

class MyReceiver < RBA::TileOutputReceiver
  def put(ix, iy, tile, obj, dbu, clip)
    puts "got area for tile #{ix+1},#{iy+1}: #{obj.to_s}"
  end
end

tp = RBA::TilingProcessor::new

# register the custom receiver
tp.output("my_receiver", MyReceiver::new)
tp.input("the_input", layout.begin_shapes(cell, layer))
tp.tile_size(100, 100)  # 100x100 um tile size
# The script clips the input at the tile and computes the (merged) area:
tp.queue("_output(my_receiver, (the_input & _tile).area)")
tp.execute("Job description")

I would like to store the area values in an array instead of putting them to the console. I'm using a global variable to do this. Is this a good idea or is there a better way?

$tile_areas = []
...
class MyReceiver < TileOutputReceiver

          def put(ix, iy, tile, obj, dbu, clip)

            area = (obj*dbu**2).round(4)

            puts "Area for tile #{ix+1},#{iy+1}: #{area.to_s}"

            $tile_areas << [ix+1, iy+1, area]

          end # def

end # class

Cheers,

Tomas

I'm looking further into the TilingProcessor feature using the attached gds file (using version 0.28.17). It's a simple layout with a 5x5 array of 200um tiles with a random square on layer 4/0 in each one of them. When running the script below, the area of the first tile is not 40000um^2 as I would expect but a bit less as shown in the output to the console.

module MyMacro

      include RBA


      layout_view = Application.instance.main_window.current_view
      cell_view = layout_view.active_cellview
      layout = cell_view.layout
      viewed_cell = cell_view.cell
      dbu = layout.dbu

#--------- input --------------------------------------------------------------------------------------------

layer = "4/0"

tile_size = 200.0

#-------------------------------------------------------------------------------------------------------------

      puts "-"*120


      layer_number = layer.split("/")[0].to_i
      datatype_number = layer.split("/")[1].to_i


      input_layer_id = layout.layer(layer_number, datatype_number)


      class MyReceiver < TileOutputReceiver

          def put(ix, iy, tile, obj, dbu, clip)

            input_area = (obj*dbu**2).round(8)

            puts "Input area of tile #{ix+1},#{iy+1} in um^2: #{input_area.to_s}\t\t\tTile Extents in um: #{tile.left*dbu}, #{tile.bottom*dbu}, #{tile.right*dbu}, #{tile.top*dbu}"

          end # def

      end # class


      tp = TilingProcessor.new


      # register the custom receiver

      tp.output("my_receiver", MyReceiver::new)

      tp.input("input_layer", layout.begin_shapes(viewed_cell, input_layer_id))

      tp.tile_size(tile_size, tile_size)

      # The script clips the input at the tile and computes the (merged) area:

      tp.queue("_output(my_receiver, (input_layer & _tile).area)")

      tp.execute("Job description")


      puts "-"*120


end # Module

First few lines of console output:

Input area of tile 1,1 in um^2: 38311.960932 Tile Extents in um: -2.593, -5.924, 197.407, 194.076
Input area of tile 1,2 in um^2: 24662.358144 Tile Extents in um: -2.593, 194.076, 197.407, 394.076
Input area of tile 1,3 in um^2: 5551.7401 Tile Extents in um: -2.593, 394.076, 197.407, 594.076
Input area of tile 1,4 in um^2: 23350.8961 Tile Extents in um: -2.593, 594.076, 197.407, 794.076
Input area of tile 1,5 in um^2: 18559.702756 Tile Extents in um: -2.593, 794.076, 197.407, 994.076
Input area of tile 2,1 in um^2: 4635.928864 Tile Extents in um: 197.407, -5.924, 397.407, 194.076
...

The tiling array seems not to be centered around the original layout's center, but rather around the center of the bbox of the input layer 4/0.

When I force the tiling origin by adding:

tp.tile_origin(0.0, 0.0)

the result is as expected:

Input area of tile 1,1 in um^2: 40000.0 Tile Extents in um: 0.0, 0.0, 200.0, 200.0
Input area of tile 1,2 in um^2: 23492.919076 Tile Extents in um: 0.0, 200.0, 200.0, 400.0
Input area of tile 1,3 in um^2: 5551.7401 Tile Extents in um: 0.0, 400.0, 200.0, 600.0
Input area of tile 1,4 in um^2: 23350.8961 Tile Extents in um: 0.0, 600.0, 200.0, 800.0
Input area of tile 1,5 in um^2: 18559.702756 Tile Extents in um: 0.0, 800.0, 200.0, 1000.0
Input area of tile 2,1 in um^2: 4132.689796 Tile Extents in um: 200.0, 0.0, 400.0, 200.0
...

Does that make sense?

Cheers,

Tomas

There is my Traversal function:

[*(0..30)].each do |level|
   shape_count = 0
   box_count = 0
   # Traversal
   top_cell.shapes(level).each do |shape|
     if shape.is_box?
       bbox = shape.bbox
       shape_id = id_counter
      id_counter += 1
      shape_info = ShapeInfo.new(shape_id, [], [])
       shape_infos << shape_info
  # Array used to save shape  
      rectangles << { box: shape.box, layer: level }
      id_to_rectangle[shape_id] = { box: shape.box, layer: level }
       box_count += 1
      # test
       puts "box: #{shape_id}"
      count_shape += 1    # shape' counts
     elsif shape.is_polygon? || shape.is_path?
      # Deal with the polygon and path 
      bbox = shape.bbox
       shape_id = id_counter
       id_counter += 1
       shape_info = ShapeInfo.new(shape_id, [], [])
      shape_infos << shape_info
  # Array used to save shape  
      rectangles << { box: bbox, layer: level }
       id_to_rectangle[shape_id] = { box: bbox, layer: level }
       count_shape += 1
      # test
      puts "bbox: #{shape_id}"
     end
     shape_count += 1
   end

   if shape_count > 0
    puts "Level #{level}: find #{shape_count} shapes， #{box_count} boxes。"
  else
     puts "Level #{level}: can't find any shape in this layer, step it."
   end
 end

Thinks，

Luan

shapes = layout.cell(cell_index).shapes(layer_info) 

and then call shapes.size() to get the number of shapes. This code runs well and quickly, but I have noticed that memory usage continues to rise. Using objgraph.show_most_common_types(), I found that the Shapes object remains in memory. Using objgraph.show_backrefs, I discovered that apart from gc.get_objects(), there are no other references. Similarly, I found that the q object inside for

 q in LayoutQuery("select cell_index, instances from cells *").each(layout)

has the same issue.I don't know how to resolve this issue, and I look forward to your response., thank you!

i sorry that it should be categorized under python scripting, but i made a mistake

Also, it would be nice to have a command "RemoveFloating" or something like that. As an example, if nitride is etched out from under an oxide mask, and that oxide mask is narrow, then the oxide mask remains floating in air. In some cases, that is ok (when intentionally suspended in Y somewhere), but in other cases it would be great to have a cleanup command that can remove any [material1, material2, etc] not connected to other materials anymore.

Thanks.
Thomas.

I am very new to Klayout scripting and would like to write my first script (ruby and/or python) which does the following:

Select a cell in a layout using cell name (e.g. “example_cell”) and change gds layer from original layer to a new layer (e.g. change from layer 112/2 to layer 101/1).

I have written the following code to generate the new gds layer (don’t know if it is the best way to do it but it works), now I’m missing the part to select cell “example_cell” and change gds layer.

app = RBA::Application.instance

mw = app.main_window

layout_view = mw.current_view

layer_info = RBA::LayerInfo.new(101,1)
layer_pn = RBA::LayerPropertiesNode::new

layer_pn.source = layer_info.to_s
layout_view.insert_layer( layout_view.end_layers, layer_pn )

Thanks for support.

I then look a little bit around and found this library for partitioning polygons, and the results seemed promising (https://github.com/ivanfratric/polypartition). Especially the Hertel-Mehlhorn algorithm seemed to work quite decent. I tried to implement a version in Ruby that is not yet smart enough to use the longest edge first (which seems to be heuristically the better one to merge), but it kind of works. Perhaps somebody finds it useful, or can improve it to be smarter or faster in the future.

class DRC::DRCLayer
  def decompose_HM()
    result = RBA::Region.new 
    self.data.each do |p|
      if p.is_convex?
        result.insert(p)
        next
      end

      # Get initial triangulation
      current_region = RBA::Region::new(p)
      triangles = current_region.delaunay
      triangles_a = triangles.each.to_a

      changed = true
      while changed
        changed = false

        # Try each pair of triangles
        (0...triangles_a.length).each do |i|
          ((i+1)...triangles_a.length).each do |j|

            merged = RBA::Region.new
            merged.insert(triangles_a[i])
            merged.insert(triangles_a[j])
            # Perform merge
            merged.merge

              # Check if result is a single convex polygon
            if merged.count == 1 and merged[0].is_convex?
              # Update triangle list
              triangles_a.delete_at([i,j].max)
              triangles_a.delete_at([i,j].min)
              triangles_a.push(merged[0])

              changed = true
              break
            end
          end
          break if changed
        end
      end
      result.insert(triangles_a)
    end
    return DRC::DRCLayer::new(@engine, result)
  end
end
#

polys = polygons("Holes")
#polys.data = polys.data.delaunay
polys.decompose_HM.output(1006)

Also if Klayout ever supports some of the Hertel-Mehlhorn algorithms or even some optimal partition algorithm like Keil and Snoeyink,
could be useful, but perhaps not very fast.

Due to this issue, I attempted to wrap the extended command with a Timeout, but KLayout still freezes at same point.

begin
   Timeout.timeout(5) do
      buff = temp.edges.extended(0,0,fineDilation,0,true)
      print "."
    end
  rescue Timeout::Error
    buff = temp.edges.extended(0,0,fineDilation,0)
    print "|"
end

Can KLayout deal with timeouts? Or does this mean the extended process is freezing KLayout and not it's script interrupter that's watching for the timeout.

sh: line 1: pmap: command not found
ERROR: In /home/X/class/chip-tutorials/klayout/tech/sky130/pymacros/../lvs/sky130.lvs: undefined method strip' for nil:NilClass ERROR: /home/X/class/chip-tutorials/klayout/tech/sky130/pymacros/run_lvs.lym:135: RuntimeError: NoMethodError: undefined methodstrip' for nil:NilClass in Executable::execute
/home/X/class/chip-tutorials/klayout/tech/sky130/pymacros/../lvs/sky130.lvs:27:in block in execute' /nix/store/c4bdx4dja3h06xg1ksv3f51alp5a44li-ruby-3.1.5/lib/ruby/3.1.0/logger.rb:586:informat_message'
/nix/store/c4bdx4dja3h06xg1ksv3f51alp5a44li-ruby-3.1.5/lib/ruby/3.1.0/logger.rb:476:in add' /nix/store/c4bdx4dja3h06xg1ksv3f51alp5a44li-ruby-3.1.5/lib/ruby/3.1.0/logger.rb:529:ininfo'
/home/X/class/chip-tutorials/klayout/tech/sky130/pymacros/../lvs/sky130.lvs:34:in execute' :/built-in-macros/lvs_interpreters.lym:31:ininstance_eval'
:/built-in-macros/lvs_interpreters.lym:31:in `execute' in Macro.run
/home/X/class/chip-tutorials/klayout/tech/sky130/pymacros/run_lvs.lym:135

I've confirmed that it works on:
Ubuntu 20.04 with Ruby 2.7.1

But it fails on:
Ubuntu 20.04 with Ruby 3.1.5 (inside Docker)
MacOS Sequoia 15 with Ruby 2.6.10

I have a demo with an inverter.

`tiles(3000.um)
threads(8)

final_metal=input(110,0)
die=input(71,0)

#

anser_list = Array.new()
anser_list << "Outer_SealRing"
anser_list << "Inner_SealRing"

seal_case=RBA::InputDialog::ask_item("need type", "SealRing type:",anser_list,1)
if seal_case=="Outter_SealRing" then
seal_ring_type=1
end

if seal_case=="Inner_SealRing" then
seal_ring_type=2
end

#

tone_list = Array.new()
tone_list << "pTone"
tone_list<< "nTone"

tone_case=RBA::InputDialog::ask_item("input final metal", "tone type:",tone_list,1)
if tone_case=="pTone" then

end

if tone_case=="nTone" then
final_metal=die-final_metal
end

#

flat
sealring_gap=15

seal_ring=final_metal.outside(die.sized(-sealring_gap*10.um))
seal_ring.holes.merged(seal_ring_type).output(111,0)`