Source code for kqcircuits.klayout_view

# This code is part of KQCircuits
# Copyright (C) 2021 IQM Finland Oy
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
# version.
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License along with this program. If not, see
# The software distribution should follow IQM trademark policy for open-source software
# ( IQM welcomes contributions to the code. Please see our contribution agreements
# for individuals ( and organizations (
import importlib
import warnings

from kqcircuits.elements.element import insert_cell_into
from kqcircuits.pya_resolver import pya, lay, is_standalone_session

from kqcircuits.defaults import (

[docs] class KLayoutView: """Helper object to represent the KLayout rendering environment. ``KLayoutView`` is a wrapper around the KLayout ``LayoutView`` and ``CellView`` objects, that represent containers for viewing a layout in the GUI. It provides methods to initialize the views and layout for KQCircuits, for placing KQCircuits ``Elements``, and for exporting images. Create a new view as follows:: view = KLayoutView() This creates a new set of ``LayoutView``, ``CellView``, ``Layout`` and top ``Cell`` objects with layers initialized to the KQCircuits layer configuration. In the KLayout GUI, the new view will show as a new tab. Note: In standalone python mode, the user must keep a reference to the ``KLayoutView`` object in scope, otherwise the associated layout and cells may also go out of scope. When running scripts or macros in the KLayout application, the following command creates a wrapper around the currently active view:: view = KLayoutView(current=True) This can be used in macros to act on the existing layout. The argument ``current=True`` is not available in standalone python mode. Once a view is created, new ``Elements`` can be placed with the ``insert_cell`` method. Several methods are available to export PNG files of the current view or specific cells and layers. In Jupyter notebooks, the ``show`` method displays the current view inline in the notebook. """ if hasattr(lay, "LayoutView"): layout_view: lay.LayoutView def __init__(self, current=False, initialize=None, background_color="#ffffff"): """Initialize a ``KLayoutView`` instance. Args: current: Boolean. If True, wrap the currently active ``LayoutView`` (not available in standalone python) initialize: Boolean, specify whether to initialize the layout with the default layer configuration and a top cell. Defaults to True if ``current==False``, and to False if ``current==True``. background_color: Background color as HTML color code. Defaults to `"#ffffff"` (white). """ if not hasattr(lay, "LayoutView"): # Standalone session before KLayout 0.28 raise MissingUILibraryException( "KLayoutView is not supported in standalone mode for this klayout version. " "Consider upgrading your klayout package to version 0.28 or above." ) if initialize is None: initialize = not current if is_standalone_session(): # Standalone session since KLayout 0.28 if current: raise MissingUILibraryException( "In standalone python mode only KLayoutView(current=False) " + "is supported." ) self.layout_view = lay.LayoutView(True) # Creates a new LayoutView in editable mode self.layout_view.show_layout(pya.Layout(), True) # Adds a CellView and Layout self.layout_view.set_config("background-color", background_color) else: # Regular session in the KLayout GUI if not current or (lay.LayoutView.current() is None): pya.MainWindow.instance().create_layout(1) self.layout_view = lay.LayoutView.current() if initialize: self.add_default_layers() self.create_top_cell()
[docs] def insert_cell( self, cell, trans=None, inst_name=None, label_trans=None, align_to=None, align=None, rec_levels=0, **parameters ): """Inserts a subcell into the first top cell (the very first cell in the cell window) It will use the given ``cell`` object or if ``cell`` is an Element class' name then directly take the provided keyword arguments to first create the cell object. If `inst_name` given, a label ``inst_name`` is added to labels layer at the ``base`` refpoint and `label_trans` transformation. Args: cell: cell object or Element class name trans: used transformation for placement. None by default, which places the subcell into the coordinate origin of the parent cell. If `align` and `align_to` arguments are used, `trans` is applied to the `cell` before alignment transform which allows for example rotation of the `cell` before placement. inst_name: possible instance name inserted into subcell properties under `id`. Default is None label_trans: relative transformation for the instance name label align_to: ``DPoint`` or ``DVector`` location in parent cell coordinates for alignment of cell. Default is None align: name of the ``cell`` refpoint aligned to argument ``align_to``. Default is None rec_levels: recursion level when looking for refpoints from subcells. Set to 0 to disable recursion. **parameters: PCell parameters for the element, as keyword argument Return: tuple of placed cell instance and reference points with the same transformation """ return insert_cell_into( self.top_cell, cell, trans, inst_name, label_trans, align_to, align, rec_levels, **parameters )
[docs] def focus(self, cell=None): """Sets a given cell as the active cell, and fits the zoom level to fit the cell. Args: cell: cell to focus on, or None to focus on the currently active cell """ if cell is not None and isinstance(cell, pya.Cell): self.layout_view.active_cellview().active().cell = cell self.layout_view.max_hier() self.layout_view.zoom_fit()
[docs] def show(self, **kwargs): """In KLayout, show this LayoutView as the current in the main window. In standalone python, display an image of the view. Requires IPython / Jupyter. Keyword arguments are passed to ``KLayoutView.get_pixels``. """ if is_standalone_session(): display = importlib.import_module("IPython.display") display.display_png(self.get_pixels(**kwargs).to_png_data(), raw=True) else: main_window = lay.MainWindow.instance() for i in range(main_window.views()): if main_window.view(i) is self.layout_view: main_window.current_view_index = i break
[docs] def close(self): """Closes the current LayoutView.""" if is_standalone_session(): self.layout_view.destroy() else: lay.MainWindow.instance().close_current_view()
@property def cell_view(self) -> "lay.CellView": """The active ``CellView``""" return self.layout_view.active_cellview() @property def layout(self) -> pya.Layout: """The active ``Layout``""" return self.cell_view.layout() @property def active_cell(self) -> pya.Cell: """The active ``Cell``, which is shown as current top in the cellview and bold in the cell window. Can be set to any Cell in the layout.""" return self.cell_view.cell @active_cell.setter def active_cell(self, cell: pya.Cell): self.cell_view.cell = cell @property def top_cell(self) -> pya.Cell: """The first top cell of the active layout.""" cells = self.layout.top_cells() return cells[0] if len(cells) else None
[docs] def clear_layers(self): """Clear the layer view.""" self.layout_view.clear_layers()
[docs] def add_default_layers(self): """Populate view with KQCircuits default layers. Adds the layers to the layout, and populates the layer view.""" self.clear_layers() layout = self.layout for layer in default_layers.values(): layout.layer(layer) self.layout_view.add_missing_layers() if default_layer_props: self.layout_view.load_layer_props(default_layer_props, True)
[docs] def create_top_cell(self, top_cell_name="Top Cell"): """Creates a new static cell and set it as the top cell.""" top_cell = self.layout.create_cell(top_cell_name) self.cell_view.cell_name = # Shows the new cell return top_cell
[docs] def export_layers_bitmaps(self, path, cell, filename=None, layers_set=None, face_id=None): """Exports each layer to a separate png image. Args: path: Directory to place the exported file in cell: Cell to export filename: Filename to export to, or None to use the cell's name. layers_set: A list of layer names to export, or None for default values specified in the layer configuration face_id: The face id for which to export the given layers, or None for general layers not associated to a face. """ if layers_set is None: layers_set = mask_bitmap_export_layers for layer_name in layers_set: layer_info = resolve_default_layer_info(layer_name, face_id) self._export_bitmap(path, cell, filename=filename, layers_set=[layer_info])
[docs] def export_all_layers_bitmap(self, path, cell, filename=None): """Exports a cell to a .png file with all layers visible Args: path: Directory to place the exported file in cell: Cell to export filename: Filename to export to, or None to use the cell's name. """ self._export_bitmap(path, cell, filename=filename, layers_set="all")
[docs] def export_pcell_png(self, path, cell, filename=None, max_size=default_png_dimensions[0]): """Exports a cell to a .png file no bigger than max_size at either dimension. Args: path: Directory to place the exported file in cell: Cell to export filename: Filename to export to, or None to use the cell's name. max_size: Maximum size of the image. """ zoom = cell.dbbox() x, y = zoom.width(), zoom.height() if max_size * x / y < max_size - 200: # 200x100 is enough for the sizebar size = (max_size * x / y + 200, max_size) else: size = (max_size, max_size * y / x + 100) self._export_bitmap(path, cell, filename=filename, layers_set="all", z_box=zoom, pngsize=size)
[docs] def get_pixels(self, cell=None, width=None, height=None, layers_set=None, box=None): """Returns a PixelBuffer render of the current view. This method first zooms to fit the whole layout and shows all hierarchy levels. If either ``width`` or ``height`` is specified, the other is chosen correspondingly to keep the same viewport aspect ratio. If neither is specified, the current viewport size is used. Args: cell: Cell to render, or None to render the currently active cell. width: image width in pixels, or None for automatic. height: image height in pixels, or None for automatic. layers_set: list of layer names to export, or None for the default set. box: DBox area to show, or None for the full layout. Returns: PixelBuffer """ if width is None and height is None: width = self.layout_view.viewport_width() height = self.layout_view.viewport_height() elif width is None: width = height * self.layout_view.viewport_width() / self.layout_view.viewport_height() elif height is None: height = width * self.layout_view.viewport_height() / self.layout_view.viewport_width() if layers_set is not None: layers_set = [resolve_default_layer_info(layer_name) for layer_name in layers_set] def export_callback(): pixel_buffer = self.layout_view.get_pixels(width, height) return pixel_buffer return self._export_bitmap_configure(export_callback, cell, layers_set, box)
[docs] @staticmethod def get_active_cell_view(): """Gets the currently active CellView. Not supported in standalone python mode. Deprecated, use ``KLayoutView(current=True).cell_view`` to get the same behavior.""" warnings.warn( "KLayoutView.get_active_cell_view will be deprecated. " + "Use instance property KLayoutView.cell_view instead.", DeprecationWarning, ) return
[docs] @staticmethod def get_active_layout(): """Gets the layout of the currently active CellView. Not supported in standalone python mode. Deprecated, use ``KLayoutView(current=True).layout`` to get the same behavior. If you already have a KLayoutView instance, use the ``layout`` property of that instance instead.""" warnings.warn( "KLayoutView.get_active_layout will be deprecated. " + "Use instance property KLayoutView.layout instead.", DeprecationWarning, ) return
[docs] @staticmethod def get_active_cell(): """Gets the active cell of the currently active CellView. Not supported in standalone python mode. Deprecated, use ``KLayoutView(current=True).active_cell`` to get the same behavior. If you already have a KLayoutView instance, use the ``active_cell`` property of that instance instead.""" warnings.warn( "KLayoutView.get_active_cell will be deprecated. " + "Use instance property KLayoutView.active_cell instead.", DeprecationWarning, ) return
# ******************************************************************************** # PRIVATE METHODS # ******************************************************************************** def _export_bitmap( self, path, cell=None, filename=None, layers_set=None, z_box=None, pngsize=default_png_dimensions ): if filename is None: filename = if layers_set is None: layers_set = [resolve_default_layer_info(layer_name) for layer_name in mask_bitmap_export_layers] if len(layers_set) == 1: layer_str = "-" + layers_set[0].name else: layer_str = "" cell_png_name = path / "{}{}.png".format(filename, layer_str) def export_callback(): self.layout_view.save_image(str(cell_png_name), pngsize[0], pngsize[1]) self._export_bitmap_configure(export_callback, cell, layers_set, z_box) def _export_bitmap_configure(self, export_callback, cell, layers_set, z_box): """Common configuration for export functions.""" def get_visibility_state(): """Get the current layer visibility and drawing focus state""" current_layer_visibility = [_layer.visible for _layer in self.layout_view.each_layer()] current_cell = self.layout_view.active_cellview().cell current_hier = (self.layout_view.min_hier_levels, self.layout_view.max_hier_levels) current_zoom = return current_layer_visibility, current_cell, current_zoom, current_hier def restore_visibility_state(layer_visibility, cell, zoom, hier): """Restore the layer visibility and drawing focus state. Assumes order of layers has not changed since calling ``get_visibility_state``""" for _layer, _visible in zip(self.layout_view.each_layer(), layer_visibility): _layer.visible = _visible self.layout_view.active_cellview().cell = cell self.layout_view.min_hier_levels, self.layout_view.max_hier_levels = hier self.layout_view.zoom_box(zoom) visibility_state = get_visibility_state() if cell is not None: self.layout_view.active_cellview().cell = cell self.layout_view.max_hier() self.layout_view.zoom_fit() # Has to be done also before zoom_box if z_box is not None: self.layout_view.zoom_box(z_box) if layers_set is None or layers_set == "all": for layer in self.layout_view.each_layer(): layer.visible = True for layer_to_hide in all_layers_bitmap_hide_layers: if layer.source_layer == layer_to_hide.layer and layer.source_datatype == layer_to_hide.datatype: layer.visible = False break else: layer_infos = self.layout.layer_infos() for layer in self.layout_view.each_layer(): # need to avoid hiding layer groups, because that could hide also layers in layers_set is_layer_group = True for layer_info in layer_infos: if pya.LayerInfo(layer.source_layer, layer.source_datatype).is_equivalent(layer_info): is_layer_group = False break if not is_layer_group: layer.visible = False for layer_to_show in layers_set: if layer.source_layer == layer_to_show.layer and layer.source_datatype == layer_to_show.datatype: layer.visible = True break if hasattr(lay, "Application"): # Make sure the layer property changes are reflected before saving the image lay.Application.instance().process_events() else: # Undocumented method timer does basically the same thing as process_events in GUI. self.layout_view.timer() export_return = export_callback() restore_visibility_state(*visibility_state) return export_return
[docs] class MissingUILibraryException(Exception): def __init__(self, message="Missing KLayout UI library."): Exception.__init__(self, message)
[docs] def resolve_default_layer_info(layer_name, face_id=None): """Returns LayerInfo based on default_layers. Assumes that layer_name is valid, and that face_id is valid or None. Args: layer_name: layer name (without face prefix for face-specific layers) face_id: id of the face from which this layer should be """ if face_id: if layer_name in default_faces[face_id]: return default_faces[face_id][layer_name] else: return default_layers[layer_name] else: return default_layers[layer_name]