[Artwork] / [QisMLib] / [Programmer's Corner]

QisMScript Commands (with QisMLib v3.24+)

List of commands supported by QisMScript

• Some commands may need an appropriate extension to be installed
• Commands only show up if the appropriate extension is installed
• Some commands may require a valid license to execute

qismscript64.exe (Console program) commands

• Only available to users/scripts of qismscript64.exe

commands

commands [search_string]

• Print a list of available commands
• Use search_string to filter that list to the ones that contain the specified string

system

system program [args]*

• Execute a system command

exit

exit

• Terminate the script

sleep

sleep interval={sleep_time_seconds}

• Pause the script for the specified duration {sleep_time_seconds}

askif

askif key={var_name} [msg={message_for_the_user}]

• Prompt the user to enter the value of a string variable {var_name} at the command prompt ONLY IF the variable has not been assigned a value
• msg if specified, uses the specified string in the prompt to the user

Built-in commands

• Available to all applications using the QisMLib system with scripting enabled

script.print_vars

script.print_vars

• Print the complete list of script variables and their values available at this moment
• Each variable will be reported as {type}.{name} = {value}
• For variables that represent object handles, {value} is an address

script.required

script.required {var_id}+

• Confirm that all of the specified var(s) have been defined before proceeding with the next command to avoid unexpected outcomes of the subsequent command execution(s)
• {var_id} represents name of one or more variables of type # (string variables) that can be referenced elsewhere in the script as ((var_id))
• This command will return an error if even one of the specified var(s) have not been defined. If this command is part of a script file, the execution of that script will be terminated

script.set

script.set {{key}={value}}+

• Define one or more string variables to be used in the script
• Once defined, a string variable can be referenced elsewhere in the script using (({key}))

script.setif

script.setif {{key}={value}}+

• Define one or more string variable ONLY IF not defined already
• Once defined, a string variable can be referenced elsewhere in the script using (({key}))

script.substr

xxxxxxxxxx
script.substr 
  in={string} 
  &out={var_name} 
  old={sub_string_to_replace} 
  new={replacement_sub_string}

• Substitute all occurrence of {sub_string_to_replace} in an input string with {replacement_string}
• The modified string is then stored in a string variable called {var_name} and can be accessed in the subsequent command using (({var_name}))

script.tokenize

xxxxxxxxxx
script.tokenize
  in={string}
  &out={var_name}
  old={string_of_separators}
  new={char_separator}

• Separate the specified string into tokens based on a list of character separators represented by {string_of_separators} and compose a new string where those tokens are concatenated using a new separator {char_separator}
• The modified string is then stored in a string variable called {var_name} and can be accessed in the subsequent command using (({var_name}))

script.if

script.if {condition} {cmd} {args}*

• Execute a command ONLY IF {condition} evaluated to TRUE

• {condition} can be one of the following:

  • {key} : TRUE if a string variable called {key} is defined and not empty
  • !{key} : TRUE if a string variable called {key} is NOT defined or is empty
  • {key}=={value} : TRUE if a string variable called {key} has been set to {value}
  • {key}!={value} : TRUE if a string variable called {key} does not exist or has a value other than {value}
  • {key}~={value} : TRUE if a string variable called {key} CONTAINS the string {value}

• {cmd} {args}* is the command to be executed if the condition is TRUE along with it's arguments

script.branch

script.branch script={script_file_path} [{key}={value}]*

• Create a branch to another script as if executing a function defined in form of that script
• {script_file_path} is the path of another script file containing commands representing the branch
• {key}={value} are optional arguments that can be passed on to the branching script and are valid only for the duration of the branch execution
• Nested branches are allowed. A branch can invoke branching commands to another script(s). There is no limit on the number of levels
• Cyclic/recursive branching while possible is to be avoided as it may lead to infinite recursion (and therefore a stack overflow)
• Errors from branching scripts are treated as warnings. Aborts (exit) are ignored

script.procedure

script.procedure {procedure_name}

• Begin definition of a new procedure called {procedure_name}
• Every script.procedure MUST have a matching script.end_procedure
• Nested procedures are not allowed. i.e A procedure cannot define another procedure from within itself. It can however, call other procedures already defined at the time of execution
• A procedure definition MUST appear before it is called using script.call or script.foreach

script.end_procedure

script.end_procedure

• Close the definition of the procedure in question

script.call

script.call {procedure_name}

• Execute the specified procedure (already defined at this point)
• All the variables (object handles and strings) defined at this point are available to the called procedure
• Procedures can call other procedures already defined at the time of execution

script.foreach

xxxxxxxxxx
script.foreach
  &token={var_name} 
  list={list_of_tokens}
  {branch={script_file_path} | call={procedure_name}}
  [sep={separator}] 
  [{key}={value}]*

• Execute a loop for each item in a list of items
• {list_of_tokens} is a string containing one or more tokens separated by separators
• {separator} if used is a list of characters to be used as separators in the list. Default separator is , (comma)
• {var_name} represents the name of a string variable that will temporarily hold a token from the specified list. The value of this token will change as this command iterates through the specified list
• {script_file_path} is the path of another script file containing commands representing the branch to be executed for each token in the list (as if it's a function)
• {procedure_name} is name of a procedure that has already been defined at this point in the execution
• {key}={value} are optional arguments that can be passed on to the branching script and are valid only for the duration of the script.foreach command
• Nested branches are allowed. A branch can invoke branching commands to another script(s). There is no limit on the number of levels
• Nested procedure calls are not allowed
• Cyclic/recursive branching while possible is to be avoided as it may lead to infinite recursion (and therefore a stack overflow)
• Errors from branching scripts are treated as warnings. Aborts (exit) are ignored

script.new_window_set

xxxxxxxxxx
script.new_window_set 
  &set={set_id}
  llur={name}:{lx},{ly},{ux},{uy}
  llwh={name}:{lx},{ly},{width},{height}
  cwh={name}:{cx},{cy},{width},{height}
  @llur={name}:{txt_file}
  @whll={name}:{txt_file}
  @whc={name}:{txt_file}
  tilerc={name}:{roi_lx},{roi_ly},{roi_ux},{roi_uy}:{cols},{rows}[:{i},{j}]*
  tilewh={name}:{roi_lx},{roi_ly},{roi_ux},{roi_uy}:{width},{height}[:{i},{j}]*
  cxy={name}:{width},{height}[:{cx},{cy}]+
  rand={name}:{roi_lx},{roi_ly},{roi_ux},{roi_uy}:{width},{height}:{count}

• Create a new set of rectangular windows

• Multiple arguments can be used for building a cumulative set

• All co-ordinates and dimensions are in file-units (e.g um, mm, inch) associated with the CAD source

• {set_id} represents name of the variable of type QisMBoxSet* associated with the newly created set

• The QisMBoxSet C++ interface can be found in qismbase.h

• {name} is a string identifier associated with a window which may be used to determine the name of the output file corresponding to that window

• {lx}, {ly}, {ux}, {uy} represent lower-left and upper-right co-ordinates

• {width}, {height} represent the window size

• {cx}, {cy} represents co-ordinates of the window center

• {txt_file} is the path to an existing text file which contains the following :-

  • for @llur= , each line contains {lx},{ly},{ux},{uy} representing one window
  • for @llwh= , the first line contains {width},{height} representing the window size and each subsequent lines contains {lx},{ly} representing the position of the window's lower-left corner
  • for @cwh= , the first line contains {width},{height} representing the window size and each subsequent lines contains {cx},{cy} representing the position of the window's center

• For generating tiles, {roi_lx},{roi_ly},{roi_ux},{roi_uy} represents the region of interest (ROI) to be tiled

• {cols},{rows} represents the number of tiles along X and Y respectively

• {width}, {height} represent the tile size

• {i},{j} is optional represents the position of one or more tiles to be added (1 <= i <= {cols} and 1 <= j <= {rows}). If used, all other tiles not in this list will be dropped

• For the random tile generator rand= , {count} represents the number of tiles to be generated at random locations within the ROI

• Every set created using this command MUST be eventually destroyed by the script using script.delete_window_set to avoid resource leaks

script.delete_window_set

script.delete_window_set $set={set_id}

• Delete a rectangular window set created using script.new_window_set
• {set_id} represents name of the variable of type QisMBoxSet* associated with set to be destroyed

script.window_set_to_file

script.window_set_to_file $set={set_id} path={txt_file_path}

• Write the specified set of windows to a TEXT file
• {set_id} represents name of the variable of type QisMBoxSet* associated with set to be used
• {txt_file_path} is the path of a TEXT file to be written where each line of the text file represents one window from the set in the format {minx},{miny},{maxx},{maxy}

script.window_set_to_string

xxxxxxxxxx
script.window_set_to_string
  $set={set_id}
  &out={var_name}
  sep={char}

• Create a string from the co-ordinates of the windows from the specified set of windows
• {set_id} represents name of the variable of type QisMBoxSet* associated with set to be used
• The new string is then stored in a string variable called {var_name} and can be accessed in the subsequent command using (({var_name}))
• The format of that string is {minx},{miny},{maxx},{maxy}[{char}{minx},{miny},{maxx},{maxy}]* where {char} is the new separator of windows

QisMLib commands

• See qismlib.h for corresponding API

• Learn more about QisMLib

  xxxxxxxxxx
  /* C++ code to initialize and close QisMLib ONCE in the duration of the program */
  ​
  /*------------------------------------------------------------------------------
  Initialize the QisMLib once at the start of the application
  * `qism_dl_path_` is the path to qismlib64.dll (libqism64.so on linux)
  * `cfg_path_` is the path to the config. file (default: qismlib.cfg in the same
    directory as qismlib dll)
  * `log_path_` is the path of the log file (default: empty/null)
  * on success, returns the handle to the QisMLib api
  ------------------------------------------------------------------------------*/
  static QisMLib* qm_lib_initialize(
    const char* qism_dl_path_, const char* cfg_path_ = 0
    )
  {
    assert(qism_dl_path_ && qism_dl_path_[0]);
  ​
    fprintf(
      stdout, "\n> initializing qismlib (%s).. (%s %s : %d)\n", qism_dl_path_,
      __FUNCTION__, __FILE__, __LINE__
      );
    
    vector<const char*> argt;
    vector<void*> argv;
    
    //if config. path specified
    if(cfg_path_ && cfg_path_[0]) {
      argt.resize(argt.size() + 1);
      argv.resize(argv.size() + 1);
      argt.back() = QISM_ARG_USECFG;
      argv.back() = (void*)(cfg_path_);
    }
  ​
    //print QisMLib version
    fprintf(stderr, "\n%s\n", ::QisMLib_get_lib_info());
  ​
    //initialize QisMLib
    char emsg[1024]; int ecode = 0;
    QisMLib* qismlib = (QisMLib*)(QisMLib_initialize_once(
      qism_dl_path_, 0, argt.size(), argt.size() ? (&argt[0]) : 0,
      argv.size() ? (&argv[0]) : 0, emsg, sizeof(emsg), &ecode
      ));
    if(!qismlib) {
      fprintf(
        stderr, "error: failed to initialize qismlib, [%d] %s\n", ecode, emsg
        );
    } else {
      //print extension report
      fprintf(stdout, "\n%s\n", qismlib->Get_extension_report());
    }
  ​
    return qismlib;
  }
  ​
  /*------------------------------------------------------------------------------
  Close QisMLib once at the end of the application
  * `qismlib_` is the handle to the QisMLib api
  ------------------------------------------------------------------------------*/
  static void qm_lib_close(
    QisMLib* qismlib_
    )
  {
    fprintf(
      stdout, "\n> closing qismlib.. (%s %s : %d)\n", __FUNCTION__, 
      __FILE__, __LINE__
      );
    QisMLib_close_once(qismlib_);
  }
  

   

lib.load_file

xxxxxxxxxx
lib.load_file
&filedb={filedb_id} 
input={input_file_path}
[layermap={layer_map_str}] 
[notext] [diskload] [emptyrefs]

• Create a database from a GDSII/OASIS/DBLOAD file

• Equivalent to QisMLib::Load_file in qismlib.h

• {filedb_id} represents name of a variable of type QisMFile* associated with the newly created database

• {input_file_path} is the path of a valid GDSII/OASIS/DBLOAD file

• {layer_map_str} if used, is a string specifying the layer mapping. e.g. ALL-NULL,1-100,2:2-200:2,3-300:0

  • re-map 1:* to 100:*
  • re-map 2:2 to 200:2
  • re-map 3:* to 300:0 (combine all datatypes of 3)
  • drop all other layers

• notext if used, drops all TEXT items

• diskload if used, retains the data section of the database on disk to reduce the memory footprint at the cost of operational speed

• emptyrefs if used, loads references to empty cells

• Every database created using this command MUST be eventually unloaded using lib.unload_file to avoid resource leaks

• This command will define two new string variables {filedb_id}.grid and {filedb_id}.units corresponding to the file grid (in meters) and units (in meters). They can be referenced elsewhere in the script using (({filedb_id}.grid)) and (({filedb_id}.units)) respectively. These will only be available while the database is alive (until lib.unload_file is called)

  xxxxxxxxxx
  //C++ equivalent of lib.load_file
  #include "qismlib.h"
  using namespace NsQisMLib;
  ​
  /*------------------------------------------------------------------------------
  Callback class to receive notifications from QisMLib during file loading
  (see qismbase.h for full API reference)
  ------------------------------------------------------------------------------*/
  class QmLibNotify: public QisMNotify
  {
  public:
    /*----------------------------------------------------------------------------
    Implement this to tell QisMLib that this callback only subscribes to 
    QisMNotifyV1 (i.e QisMNotify)
    ----------------------------------------------------------------------------*/
    void* QisMNotify_cast(const int version) {
      switch(version) {
        case 0: return this;
        case 1: return dynamic_cast<QisMNotify*>(this);
      }
      return 0;
    } 
  ​
    /*----------------------------------------------------------------------------
    Implement this to tell QisMLib that this callback only subscribes to 
    QisMNotifyV1 (i.e QisMNotify)
    ----------------------------------------------------------------------------*/
    const void* QisMNotify_cast(const int version) const {
      switch(version) {
        case 0: return this;
        case 1: return dynamic_cast<const QisMNotify*>(this);
      }
      return 0;
    } 
  ​
    /*----------------------------------------------------------------------------
    Implement this to tell QisMLib that this callback only subscribes to 
    QisMNotifyV1 (i.e QisMNotify)
    ----------------------------------------------------------------------------*/
    int QisMNotify_latest_version() const {
      return 1; 
    } 
    
    /*----------------------------------------------------------------------------
    Recieve the progress notification
    ----------------------------------------------------------------------------*/
    int On_qismt_progress(
      const char* pre_, const char* msg_, const char* post_
      )
    {
      if(msg_ && msg_[0]) fprintf(stderr, "%s%s%s", pre_ ? pre_ : "", msg_, post_ ? post_ : "");
      return 0;
    }
  ​
    /*----------------------------------------------------------------------------
    Recieve the warning notification
    ----------------------------------------------------------------------------*/
    int On_qismt_warning(
      const char* pre_, const char* msg_, const char* post_
      )
    {
      if(msg_ && msg_[0]) fprintf(stderr, "\n**warning** %s\n", msg_);
      return 0;
    }
  };
  ​
  /*------------------------------------------------------------------------------
  Load the file database (see qismlib.h for full API reference)
  * `qismlib_` is the handle to the QisMLib api
  * `input_path_` is the path of a valid GDSII/OASIS/DBLOAD file
  * `input_layer_map_` if specified is the input layer mapping scheme
  * `no_text_` if specified controls if the TEXT elements are loaded or not
  * `disk_load_` if specified controls if the database is disk based or not
  * `empty_refs_` if specified controls if references to empty cells are loaded
    or not
  * Returns handle to the newly created QisMFile database
  ------------------------------------------------------------------------------*/
  static QisMFile* qm_lib_load_file(
    QisMLib* qismlib_, const char* input_path_, const char* input_layer_map_ = 0,
    const bool no_text_ = false, const bool disk_load_ = false, 
    const bool empty_refs_ = false
    )
  {
    fprintf(
      stdout, "\n> loading file.. (%s %s : %d)\n", __FUNCTION__, 
      __FILE__, __LINE__
      );
    assert(qismlib_ != 0);
    assert(input_path_ && input_path_[0]);
  ​
    QisMFileLoadCtrl* load_opts = qismlib_->New_loadFile_ctrl();
    assert(load_opts != 0);
  ​
    load_opts->Set_layer_map(input_layer_map_);
    load_opts->Set_file_data_on_disk(disk_load_);
    load_opts->Set_ignore_texts(no_text_);
    load_opts->Set_load_empty_refs(empty_refs_);
  ​
    QmLibNotify cb;
    QisMFile* filedb = qismlib_->Load_file(
      input_path_, load_opts, dynamic_cast<QisMNotify*>(&cb)
      );
    if(!filedb) {
      fprintf(
        stderr, "error: failed to load '%s', %s\n", input_path_, 
        qismlib_->Get_last_error_msg()
        );
    }
  ​
    qismlib_->Delete_loadFile_ctrl(load_opts);
    return filedb;
  }
  

   

lib.load_gds_with_mmaps

xxxxxxxxxx
lib.load_gds_with_mmaps
  &filedb={id}
  gds={path}
  [mapsdir={dir_path}]
  [layermap={layermap_string}]
  [notext]
  [memload]
  [emptyrefs]

• Load a GDSII file with the option of making use of .load memory maps (database disk image) to speed up the loading
• Equivalent to the C++ API QisMLibV3::Load_gds_with_memory_maps (qismlib.h)
• {id} is name of a variable of type QisMFile* to be associated with the newly created database object
• {path} is the path of the source GDSII file to be loaded (which was also used to create the memory maps)
• {dir_path} if specified is the directory to find the .load and .scan memory map files. If omitted, the map files are implied to reside in the current working directory
• {layermap_string} if specified filters/re-maps layers. See lib.load_file for syntax
• notext if specified ignores TEXT elements. (default: TEXT elements if present are loaded)
• memload if specified loads the database in memory for faster operations. (default: the database is loaded from disk)
• emptyrefs if specified drops all references to empty cells
• Every database object created with this command MUST be eventually destroyed using lib.unload_file to avoid memory/resource leaks
• If suitable memory maps are not found or the ones that are found have incompatible characteristics, the specified GDSII file is loaded directly without taking advantage of any memory maps just like lib.load_file

lib.unload_file

lib.unload_file $filedb={filedb_id}

• Destroy a QisMFile database

• Equivalent to QisMLib::Unload_file in qismlib.h

• {filedb_id} represents name of a variable of type QisMFile* associated with the database to be destroyed

  xxxxxxxxxx
  //C++ equivalent of lib.unload_file
  #include "qismlib.h"
  using namespace NsQisMLib;
  ​
  /*------------------------------------------------------------------------------
  Destroy the file database (see qismlib.h for full API reference)
  * `qismlib_` is the handle to the QisMLib api
  * `filedb_` is the handle to a valid QisMFile database
  ------------------------------------------------------------------------------*/
  static void qm_lib_unload_file(QisMLib* qismlib_, QisMFile* filedb_)
  {
    fprintf(
      stdout, "\n> un-loading file.. (%s %s : %d)\n", __FUNCTION__, 
      __FILE__, __LINE__
      );
    assert(qismlib_ != 0);
    qismlib_->Unload_file(filedb_);
  }
  

   

QisMBStore commands

• See qismbstore.h for relevant API

store.write_as_polys

xxxxxxxxxx
store.write_as_polys
  $bin={bin_id}
  path={output_base_path}
  grid={grid_m}
  units={units_m}
  [format={GDS | OAS}]
  [top={top_cellname}]

• Write a boundary container to disk as a GDSII or OASIS file
• {bin_id} represents name of a variable of type QisMBStore* associated with the container to be written
• {output_base_path} is the directory + file name of the output file. The extension (.gds or .oas) is automatically added based on the format
• {grid_m} and {units_m} are the file grid and units in meters. e.g for a micron file with nano meter resolution, grid = 1e-9 (nm) and units = 1e-6 (um)
• format if used determines the file format. Default -- GDS
• {top_cell_name} if used writes the top cell name as specified. Default -- "TOP"

store.write_as_image

xxxxxxxxxx
store.write_as_image
  $bin={bin_id}
  path={output_base_path}
  grid={grid_m}
  units={units_m}
  resolution={PXSIZE | DPI | GRID},{x}[,{y}]
  [format={TIF | BMP | RAW}]
  [invert]
  [right_to_left]
  [dither=0.0-1.0]

• Write a boundary container as a monochrome bitmap image in TIFF/BMP/RAW format

• Requires the QisMRaster extension to be installed and configured

• Requires 1 license of (14827) per call

• {bin_id} represents name of a variable of type QisMBStore* associated with the container to be written

• {output_base_path} is the directory + file name of the output file. The extension (.tif, .bmp or .raw) is automatically added based on the format

• {grid_m} and {units_m} are the file grid and units in meters. e.g for a micron file with nano meter resolution, grid = 1e-9 (nm) and units = 1e-6 (um)

• resolution can be specified in both X and Y directions as :-

  • PXSIZE -- size of 1 pixel in file units
  • DPI -- dots per inch
  • GRID -- as a multiple of the file grid

• Pixels can be square {x} == {y} or rectangle {x} != {y} . If {y} is omitted, {y} = {x}

• format if specified, determines the file format. Default -- TIF

• invert if used, reverses the image polarity (black (0) data on white (1) background)

• right_to_left if used, rasterizes the data from right to left. i.e. min-x of the data appears on the right hand size (max-x) of the image

• dither if used, generates a dithered image using a 8x8 Bayer matrix. The dithering value must be from 0.0 (max. 0 pixels/8x8 pixel data block) to 1.0 (max. 64 pixels/8x8 pixel data block)

store.print_info

store.print_info $bin={bin_id}

• Print information about a container of boundaries
• {bin_id} represents name of a variable of type QisMBStore* associated with the container to be written

QisMFile commands

• See qismfile.h for corresponding API

file.print_report

file.print_report $filedb={filedb_id}

• Print the report for the specified database

• Equivalent to QisMFile::Get_file_report in qismfile.h

• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job

  xxxxxxxxxx
  /* Equivalent C++ code */
  #include "qismfile.h"
  using namespace NsQisMLib;
  ​
  /*------------------------------------------------------------------------------
  Print a report of the specified QisMFile database
  * `filedb_` is the handle to the database in question
  ------------------------------------------------------------------------------*/
  static void qm_file_print_report(
    QisMFile* filedb_
    )
  {
    assert(filedb_);
    fprintf(
      stdout, "\n> printing database report.. (%s %s : %d)\n", __FUNCTION__, 
      __FILE__, __LINE__
      );
    fprintf(stdout, "\n%s\n", filedb_->Get_file_report());
  }
  

   

file.get_default_cell

file.get_default_cell $filedb={filedb_id} [&var={var_id}]

• Get the name of the default cell (top cell with the deepest hierarchy or largest extents)
• Equivalent to QisMFile::Get_default_top_cell in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• {var_id} if used, sets a string variable of that name to the returned cell name so that it can be used in the subsequent script commands using (({var_id})). e.g. &var=CELL will cause all occurrences of ((CELL)) in the subsequent commands to be replaced by the returned cell name before those commands are executed

file.print_cells

file.print_cells $filedb={filedb_id} [extents] [&var={var_name}]

• Print a list of all cells in the database
• Equivalent to QisMFile::Get_cell_list in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• extents if used, also prints the extents of each cell in the list
• {var_name} if used represents name of a string variable to store comma-separated list of cell names. It can be referenced in subsequent commands using (({var_name}))

file.print_top_cells

file.print_top_cells $filedb={filedb_id} [extents] [&var={var_name}]

• Print a list of top cells in the database
• Equivalent to QisMFile::Get_top_cell_list in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• extents if used, also prints the extents of each cell in the list
• {var_name} if used represents name of a string variable to store comma-separated list of cell names. It can be referenced in subsequent commands using (({var_name}))

file.print_child_cells

file.print_child_cells $filedb={filedb_id} cell={cellname} [extents] [&var={var_name}]

• Print a list of cells directly referenced by the specified cell
• Equivalent to QisMFile::Get_cell_children_list in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• extents if used, also prints the extents of each cell in the list
• {var_name} if used represents name of a string variable to store comma-separated list of cell names. It can be referenced in subsequent commands using (({var_name}))

file.get_cell_extents

file.get_cell_extents $filedb={filedb_id} [cell={cellname}] [&var={var_id}]

• Get extents of the specified cell
• Equivalent to QisMFile::Get_cell_extents in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• {cellname} if used, represents the name of the cell in question. If omitted, the default cell is used
• {var_id} if used, sets a string variable of that name to the returned extents so that it can be used in the subsequent script commands using (({var_id})). e.g. &var=EXTS will cause all occurrences of ((EXTS)) in the subsequent commands to be replaced by the returned extents before those commands are executed. The extents are preserved in the format {minx},{miny},{maxx},{maxy}

file.print_layers

file.print_layers $filedb={filedb_id} &var={var_name}

• Print a list of all layers in the database
• Equivalent to QisMFile::Get_layer_list in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• {var_name} if used represents a string variable to store a comma-separated list of layer:datatype. It can be referenced in subsequent commands using (({var_name}))

file.save_memory_maps

file.save_memory_maps $filedb={filedb_id} [outdir={output_directory}]

• Save the database as memory maps (cache) on disk
• This feature works for GDSII files only
• Equivalent to QisMFileV2::SaveAs_memory_maps in qismfile.h
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job

file.print_cell_tree

file.print_cell_tree $filedb={filedb_id} [cell={cellname}]

• Print the tree (hierarchy) for the specified cell
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• {cellname} if used, is the name of the cell whose tree is to be printed. If omitted, the entire database hierarchy (trees of all top cells) is printed

file.create_exploder

file.create_exploder &exploder={exploder_id} $filedb={filedb_id}

• Create an instance of the exploder (spatial query object)
• Equivalent to QisMFile::Create_exploder in qismfile.h
• Requires 1 license of license (11027) per call
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder to be created
• Every exploder object created using this command MUST be destroyed using file.destroy_exploder to avoid resource leaks

file.destroy_exploder

file.destroy_exploder $exploder={exploder_id} $filedb={filedb_id}

• Destroy an exploder
• Equivalent to QisMFile::Destroy_exploder in qismfile.h
• Releases 1 license of (11027) acquired during file.create_exploder
• {filedb_id} represents name of a variable of type QisMFile* associated with a file database created using lib.load_file or rtcr.setup_job that was used to create this exploder
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder to be destroyed

QisMExplCounter commands

• see qismexplcounter.h for corresponding API

explcounter.break_window_by_vertnum

xxxxxxxxxx
explcounter.break_window_by_vertnum
  $filedb={filedb_id}
  maxvert={max_vert_per_window}
  [cell={cellname}] 
  [layers={layer_list}] 
  [$tiles={window_set_id}]
  [thrnum={n_threads}] 
  [gds={output_gds_path}] 
  [minvert={min_vert_per_window}]
  [&var={new_set_id}]

• Break a region of interest into tiles based on the no. vertices contained within (a.k.a density map of the ROI)

• Equivalent to QisMExplCounterV3::Break_window_by_vertnum in qismexplcounter.h

• {filedb_id} is name of a variable of type QisMFile* associated with the file database to be used

• {max_vert_per_window} is the max. no. vertices contained in any of the computed tiles. Larger windows will be broken up into smaller ones until this criteria is satisfied

• {cellname} if specified is the view cell to be used. Default : default top cell

• {layer_list} is a comma-separated list of layer or layer:datatype numbers to be treated as a single group. Default: ALL available layers

• {window_set_id} if specified is name of a variable of type QisMBoxSet* associated with a list of windows that represents a pre-computed tiles over which this computation will be performed. Use this to:

  • Perform computation only over select areas of the view
  • Control the aspect ratio of the computed tiles
  • Save time by breaking up the ROI into smaller tiles

• {n_threads} if specified is the no. threads to be used to perform this operation. Default: 0 i.e no. cpus in the system. If {n_threads} > 1, the input ROI(s) may be further split into smaller tiles for better multi-threaded load sharing

• {output_gds_path} if specified generates a .sf (GDSII) file at the specified path illustrating the newly computed windows

• {min_vert_per_window} is the min. no. vertices per window. Windows smaller than this count will be dropped from the output

• {set_id} if specified, is name of a variable of type QisMBoxSet* associated with a newly created list of tiles. It MUST be eventually destroyed using explcounter.delete_windows

explcounter.break_window_by_crossing

xxxxxxxxxx
explcounter.break_window_by_crossing
  $filedb={filedb_id}
  gds={output_gds_path} 
  [cell={cellname}] 
  [layers={layer_list}] 
  [window={minx},{miny},{maxx},{maxy}]
  [maxd={max_quad_depth}]
  [maxv={max_vertices_per_quad}]
  [limitpct={percentage}]
  [lout={output_layer}]
  [&var={set_id}]

• Break a region of interest into tiles based on the no. vertices crossing a region of the ROI
• Uses a quad-tree based algorithm to compute density map. Suitable for cases where the no. intersections between polygons outweigh the no. vertices
• {filedb_id} is name of a variable of type QisMFile* associated with the file database to be used
• {cellname} if specified is the view cell to be used. Default : default top cell
• {layer_list} is a comma-separated list of layer or layer:datatype numbers to be treated as a single group. Default: ALL available layers
• window if specified represents the region of interest (default: extents of the view cell)
• {output_gds_path} generates a (GDSII) file at the specified path illustrating the newly computed windows
• {max_quad_depth} if specified controls the resolution of the density map by setting the max. depth of the quad-tree. Increasing the depth increases the resolution of the density map (default: 8)
• {max_vertices_per_quad} if specified controls the breaking up of quads based on the max. no. vertices per leaf quad (default: 1024). Increasing the max. no. vertices reduces the resolution of the density map
• {percentage} if specified limits the no. output tiles to the specified percentage of the original no. computed tiles (default: 100)
• {output_layer} if specified writes the tiles to {output_layer}:0 in the output file
• {set_id} if specified, is name of a variable of type QisMBoxSet* associated with a newly created list of tiles. It MUST be eventually destroyed using explcounter.delete_windows

explcounter.delete_windows

explcounter.delete_windows $windows={set_id}

• Destroy a set of windows allocated by the explcounter commands
• {set_id} is name of a variable of type QisMBoxSet* associated with the list of windows to be destroyed

QisMWindowProbe commands

• see qismwindowprobe.h for corresponding API

  xxxxxxxxxx
  /* C++ code to get access to QisMWindowProbe extension API */
  #include "qismlib.h"
  #include "qismwindowprobe.h"
  using namespace NsQisMLib;
  ​
  bool probe_get_extension_api(QisMLib* qismlib, QisMWindowProbe*& probe_api)
  {
    assert(qismlib != NULL);
    QisMExtensionAPI* extn = qismlib->Get_extension_api(QISMEXTENSION_WINDOWPROBE);
    if(!extn) {
      fprintf(
        stderr, "error: failed to locate extension '%s'", QISMEXTENSION_WINDOWPROBE
        );
      return false;
    }
    probe_api = (QisMWindowProbe*)(extn->Extension_class_ptr());
    return true;
  }
  

probe.window

xxxxxxxxxx
probe.window 
  $filedb={filedb_id} 
  window={minx},{miny},{maxx},{maxy} 
  [cell={cellname}]
  [layers={layer_list}]
  [nesting={nesting_level}]

• Probe a rectangular window to collect statistical information corresponding to an extensible list of parameters

• Makes use of QisMWindowProbeObj class in qismwindowprobe.h

• {filedb_id} represents name of a variable of type QisMFile* associated with the file database to be probed

• {minx}..{maxy} are the extents of the window to be probed

• {cellname} if used represents the view cell (otherwise, the default top cell is used)

• {layer_list} if used is a comma separated list of layer[:datatype] or "ALL". Default is ALL layers

• {nesting_level} if used is the max. nesting level to probe up to. Default is 0 (all nesting levels)

• At the moment, the following parameters are probed and printed:

  • Polygon extents : Cumulative extents of all the polygons that cross the specified view
  • Polygon counts : Total number of polygons that cross the specified view
  • Polygon vertex counts : Sum of vertices of all polygons that cross the view

  xxxxxxxxxx
  /* C++ equivalent to probe.window */
  #include "qismlib.h"
  #include "qismwindowprobe.h"
  using namespace NsQisMLib;
  ​
  bool probe_window(
    QisMWindowProbe* probe_api, QisMFile* filedb, const double lx, const double ly, 
    const double ux, const double uy, const char* cell, const char* layers, 
    const int nesting
    )
  {   
    assert(probe_api != NULL);
    assert(filedb != NULL);
    
    QisMWindowProbeObj* probe_obj = 0;
    int ecode = probe_api->Create_probe(probe_obj, filedb);
    if(ecode != 0) {
      fprintf(
        stderr, "error: failed to create probe, %s", probe_api->Get_error_msg(ecode)
        );
      return false;
    }
    
    const QisMWindowProbeData* results = 0;
    ecode = probe_obj->Probe_window(results, lx, ly, ux, uy, cell, layers, nesting);
    if(ecode != 0) {
      fprintf(stderr, "probe failed, %s", probe_obj->Get_error_msg(ecode));
      probe_api->Destroy_probe(probe_obj);
      return false;
    }
    
    double p_lx = 0.0, p_ly = 0.0, p_ux = 0.0, p_uy = 0.0; long long n_p = 0, n_pv = 0;
    results->Get_param_info(
      QisMWProbeParam::PRB_POLY_EXTENTS, &p_lx, &p_ly, &p_ux, &p_uy
      );
    results->Get_param_info(QisMWProbeParam::PRB_POLY_COUNT, &n_p);
    results->Get_param_info(QisMWProbeParam::PRB_POLY_VERT_COUNT, &n_pv);
    
    fprintf(stdout, "Actual polygon extents: %g, %g, %g, %g\n", p_lx, p_ly, p_ux, p_uy);
    fprintf(stdout, "Polygon counts: %lld (%lld vertices)\n", n_p, n_pv);
    
    probe_api->Destroy_probe(probe_obj);
    return true;
  }
  

QisMExploder commands

• see qismview.h and qismexploder.h for corresponding API

exploder.set_view

xxxxxxxxxx
exploder.set_view
  $exploder={exploder_id}
  [reset] | {
    [cell={cellname}]
    [layers_on={list} | layers_off={list}]
    [window={minx},{miny},{maxx},{maxy}]
    [nesting={level>0}]
    [inside]
  }

• Set the exploder view
• Equivalent to various QisMExploder::Set_* methods in qismexploder.h or qismview.h
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder
• If reset is specified, all other options are ignored and the view is reset to default options
• {cellname} if used, represents the view cell (default -- file.get_default_cell)
• {list} if used, represents a comma-separated list of layers or "ALL" . e.g. 1,2:2,3:3,3:4,4 (default -- ALL on)
• {minx}..{maxy} if used, represents the window co-ordinates in file units (default -- extents of the view cell)
• {level} if used, represents the max. number of nesting levels to traverse (default -- all levels)
• inside if used, only vectors fully inside the view window will be returned. Partially crossing vectors will be dropped (default -- all vectors crossing the view window, partial or full, will be processed)

exploder.get_boundaries

exploder.get_boundaries $exploder={exploder_id} &bin={bin_id}

• Get the boundaries for the view set in the exploder (see exploder.set_view) and store it in a container
• Equivalent to QisMExploderV2::Get_boundaries in qismexploder.h
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder
• {bin_id} represents name of a variable of type QisMBStore* associated with the container where the boundaries will be stored
• Paths if any, will be converted to boundaries
• Every container created using this command MUST be eventually destroyed using exploder.delete_store to avoid resource leaks

exploder.delete_store

exploder.delete_store $bin={bin_id}

• Delete a container of boundaries of type QisMBStore* only created by exploder.get_boundaries
• {bin_id} represents name of a variable of type QisMBStore* associated with the container to be destroyed

exploder.write_texts_to_file

exploder.write_texts_to_file $exploder={exploder_id} file={ascii_file_path} [sort]

• Explode TEXT data and write them to a file
• Uses QisMExploder::Get_vector_data in qismexploder.h to collect TEXT vectors from a view
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder
• {ascii_file_path} is the path where an ASCII (text) file will be created
• Each line of the file represents one TEXT vector in the format {text_string},{parent_cell},{x_dbu},{y_dbu},{layer},{texttype}
• sort if specified will sort the items in format order before writing

exploder.write_srefs_to_file

exploder.write_srefs_to_file $exploder={exploder_id} file={ascii_file_path} [sort]

• Explode SREF (single cell reference) data and write them to a file
• Uses QisMExploder::Get_vector_data in qismexploder.h to collect SREF vectors from a view
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder
• {ascii_file_path} is the path where an ASCII (text) file will be created
• Each line of the file represents one SREF vector in the format {ref_cell},{parent_cell},{x_dbu},{y_dbu},{scale},{angle},{mirror 'N' | 'X'}
• sort if specified will sort the items in format order before writing

exploder.write_arefs_to_file

exploder.write_arefs_to_file $exploder={exploder_id} file={ascii_file_path} [sort]

• Explode AREF (array cell reference) data and write them to a file
• Uses QisMExploder::Get_vector_data in qismexploder.h to collect AREF vectors from a view
• {exploder_id} represents name of a variable of type QisMExploder* associated with the exploder
• {ascii_file_path} is the path where an ASCII (text) file will be created
• Each line of the file represents one AREF vector in the format {ref_cell},{parent_cell},{x_dbu},{y_dbu},{scale},{angle},{mirror 'N' | 'X'},{columns},{rows},{col_dx_dbu},{col_dy_dbu},{row_dx_dbu},{row_dy_dbu}
• sort if specified will sort the items in format order before writing

QisMDraw commands

draw.window

xxxxxxxxxx
draw.window
  $filedb={filedb_id} 
  [path={img_path_base}] 
  [cell={cellname}]
  [layers={layer_list}] 
  [window={minx},{miny},{maxx},{maxy}] 
  [nesting={level}]
  [format={GIF | DIB | XPM}] 
  [background={BLACK | WHITE}] 
  [filtersize={dfs}]
  [fill={ON | OFF}] 
  [text={ON | OFF}] 
  [res={x},{y}] 
  [refboxes={ON | OFF | NL}]

• Render a view of the database to an colored image file on disk
• Makes use of the QisMDraw API defined in qismdraw.h
• Requires ONE license of (11057) per call
• {filedb_id} is name of the variable of type QisMFile* associated with the file database
• {img_base_path} if specified generates an output file at the specified path (extension automatically added). Otherwise, the image is generated but not written to disk
• {cellname} if specified set the view cell. Default view cell is the deepest top cell
• {layer_list} if specified, is a comma-separated list of layer and/or layer:datatype numbers to be visible. Default: ALL loaded layers
• {minx}..{maxy} if specified represents the window to be set (adjusted to match the image aspect ratio). Default: Extents of the view cell is used
• {level} if specified sets a max. nesting level for drawing. Default: ALL levels
• format if specified sets the output file format. Default: GIF. XPM is only available on Linux.
• background if specified sets the background color. Default: BLACK
• {dfs} if specified sets the display filter size (for both geometries and references). Default: 0
• fill controls the fill mode. Default : OFF
• text controls if TEXT elements are drawn. Default: ON
• {x},{y} if used is the image resolution in pixels along X and Y. Default: 800, 600 pixels
• refboxes if specified controls if the references are drawn with outlines and labels. If ON, references at all nesting levels are drawn with outline and labels. If OFF, outlines and labels are not drawn. If NL, outlines and labels are only drawn for references at the specified nesting level (> 0)

QisMBool Commands

• corresponds to the QisMBool API in qismbool.h

bool.create_instance

xxxxxxxxxx
bool.create_instance &bool={boolinst_id}

• Create an instance of the Boolean object
• Equivalent to QisMBool::Create_instance in qismbool.h
• {boolinst_id} is name of a variable of type QisMBoolInst* to be associated with the newly created Boolean object
• Requires ONE license of (11047) which is released by bool.destroy_instance
• Every object created by this command MUST be eventually destroyed by bool.destroy_instance to avoid resource leaks

bool.destroy_instance

xxxxxxxxxx
bool.destroy_instance $bool={boolinst_id}

• Destroy an instance of the Boolean object
• Equivalent to QisMBool::Destroy_instance in qismbool.h
• {boolinst_id} is name of a variable of type QisMBoolInst* associated with the object to be destroyed

bool.create_settings

xxxxxxxxxx
bool.create_settings &settings={settings_id}

• Create an instance of the Boolean settings object
• Equivalent to QisMBool::New_settings in qismbool.h
• {settings_id} is name of a variable of type QisMBoolSettingsV2* to be associated with the newly created object
• Every object created by this command MUST be eventually destroyed by bool.destroy_settings to avoid memory leak

bool.destroy_settings

xxxxxxxxxx
bool.destroy_settings $settings={settings_id}

• Destroy an instance of the Boolean settings object
• Equivalent to QisMBool::Delete_settings in qismbool.h
• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the object to be destroyed

boolsettings.set

xxxxxxxxxx
boolsettings.set
  $settings={settings_id}
  [reset]
  [sliver={sliver_value}]
  [clip={minx},{miny},{maxx},{maxy}]
  [butting={overlap}]
  [maxvert={count}]
  [passthru={ON | OFF}]
  [mergestripes={ON | OFF}]
  [convex={OFF | X | Y | FULL | HTRAP | VTRAP}]
  [sizing={OFF | STD | ISOTR | NONISOTR}[,{sizing_x}[,{sizing_y}]]]
  [rndcorners={RTANGLE | THREEPT | FIVEPT}]
  [cutlines] [lnvout] [lnvin={A | B | ALL | NONE}]
  [grid={grid_m}] [units={units_m}]

• Set various Boolean settings
• Equivalent to QisMBoolSettingsV2::Set_param in qismbool.h
• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the settings object to be used
• reset if specified, resets all the settings to default values first before applying any other parameters
• {sliver_value} if specified sets the sliver parameter for removal of polygons (slivers) smaller than the specified threshold (in file units). Default: no filtering of tiny polygons
• {minx}..{maxy} if specified sets the clipping window (in file units). Any polygon crossing this window will be clipped. Default: no clipping
• {overlap} if specified (even 0.0), sets the polygon output mode to BUTTING with the specified overlap value along butting edges (in file units). Default: Polygons with holes have cutlines
• {count} if specified sets the max. vertex count for any output polygon. Larger polygons are broken up into smaller ones. Default: 8190 vertices
• passthru if specified sets/resets the pass through mode. If ON, the core boolean operation will be bypassed and only the output formatting procedures (such as clipping) will be run (Works only with boolinst.union). Default: OFF
• mergestripes if ON will force the removal of all edges that were created because of data partitioning across multiple threads. Default: OFF
• convex if specified activates convex mode for the output polygons. Default: OFF
• sizing if specified activates the sizing mode for output polygons. Default: OFF. For STD and ISOTR, {sizing_x} MUST be specified (in file units). For NONISOTR, both {sizing_x} and {sizing_y} MUST be specified
• rndcorners if specified controls sharp corners are handled during sizing. Default: (if ISOTR | NONISOTR sizing) THREEPT
• lnvout if specified sets the output polygon format to Leonov
• cutlines if specified sets the output polygon format to cutlines
• lnvin if specified indicates the format for the source polygons. A , B implies that only the specified operand is in Leonov format. ALL implies both operands are Leonov. NONE (default) implies none of the operands are Leonov.
• {grid_m} and {units_m} if specified represent the data units and resolution. Default: 1e-9 (nm) and 1e-6 (um) respectively
• All dimensional values in file units

boolinst.union

xxxxxxxxxx
boolinst.union
  $bool={boolinst_id}
  $settings={settings_id}
  $in={input_bin_id}
  &out={output_bin_id}
  [thrnum={n_threads}]
  [layer={layer}]

• Unionize a set of polygons
• Equivalent to QisMBoolInst::UnionMT in qismbool.h
• {boolinst_id} is name of a variable of type QisMBoolInst* associated with the boolean object to be used
• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the object holding the boolean settings
• {input_bin_id} is name of a variable of type QisMBStore* associated with a set of polygons to be used as the source
• {output_bin_id} is name of a variable of type QisMBStore* to be associated with the newly created set of resulting polygons
• {n_threads} if specified indicates the number of threads to be used for this operation. Default: no. system processors
• layer if specified indicates the layer number to be associated with the output polygons. Default : 0
• The output set of polygons MUST be eventually destroyed using boolinst.delete_store to avoid memory leak

boolinst.binary

xxxxxxxxxx
boolinst.binary
  $bool={boolinst_id}
  $settings={settings_id}
  $bin_a={operand_a_bin_id}
  $bin_b={operand_b_bin_id}
  &out={output_bin_id}
  [op={UNION | INTERSECTION | DIFFERENCE | XOR}]
  [thrnum={n_threads}]
  [layer={layer}]

• Perform binary operation between two sets of polygons
• Equivalent to QisMBoolInst::BinaryMT in qismbool.h
• {boolinst_id} is name of a variable of type QisMBoolInst* associated with the boolean object to be used
• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the object holding the boolean settings
• {operand_a_bin_id} and {operand_b_bin_id} are names of variables of type QisMBStore* associated with a set of polygons to be used as the operand A and operand B respectively. The operation to be performed is A op B.
• {output_bin_id} is name of a variable of type QisMBStore* to be associated with the newly created set of resulting polygons
• op if specified represents the boolean operator. Default: UNION
• {n_threads} if specified indicates the number of threads to be used for this operation. Default: no. system processors
• layer if specified indicates the layer number to be associated with the output polygons. Default : 0
• The output set of polygons MUST be eventually destroyed using boolinst.delete_store to avoid memory leak

boolinst.delete_store

boolinst.delete_store $bin={bin_id}

• Destroy a set of polygons created by boolinst.union or boolinst.binary ONLY
• {bin_id} is name of a variable of type QisMBStore* associated with the polygon set to be destroyed
• Equivalent to QisMBoolInst::Release in qismbool.h

QisMCADWriter Commands

cadwriter.open

xxxxxxxxxx
cadwriter.open 
  &writer={writer_id}
  grid_m={grid_in_meters}
  units_m={units_in_meters}
  path={output_file_path}
  [format={GDS|OAS}]

• Open a GDSII/OASIS file composer
• {writer_id} is name of a variable of type QisMCADWriterV2* to be associated with the writer object
• {grid_in_meters} is the file resolution expressed in meters
• {units_in_meters} is the file units expressed in meters
• {output_file_path} is the path (dir + name + extension) where the output file will be created
• format if specified determines the file format (default : GDS)
• Every open MUST have a corresponding close

cadwriter.begin_cell

cadwriter.begin_cell $writer={writer_id} name={cellname}

• Open a cell definition
• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object
• {cellname} is name of the cell to be defined
• Every begin_cell MUST have a corresponding end_cell

cadwriter.box

xxxxxxxxxx
cadwriter.box
  $writer={writer_id}
  box={minx},{miny},{maxx},{maxy}
  [layer={layer}:{datatype}]

• Write a rectangular box to the current cell
• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object
• {minx}..{miny} are the min-max extents of the box in file units
• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

cadwriter.box_set

xxxxxxxxxx
cadwriter.box_set
  $writer={writer_id}
  $set={box_set_id}
  [layer={layer}:{datatype}]

• Write a set of rectangular boxes to the current cell
• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object
• {box_set_id} is name of a variable of type QisMBoxSet* associated with the set of boxes to be written
• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

cadwriter.bstore

xxxxxxxxxx
cadwriter.bstore
  $writer={writer_id}
  $bin={bstore_id}

• Write a set of boundaries to the current cell
• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object
• {bstore_id} is name of a variable of type QisMBStore* associated with the set of boundaries to be written

cadwriter.boundary

xxxxxxxxxx
cadwriter.boundary
  $writer={writer_id}
  {{deltas={dx0},{dy0},{dx1},{dy1}[,{dx},{dy}]* pos={x},{y}} | xy={x1},{y1}..{xn},{yn}}
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [layer={layer}:{datatype}]

• Write a boundary to the current cell (with or without repetitions)

• All co-ordinates are in file units

• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object

• deltas is a list of offsets from the boundary origin 0,0 that form the vertices of the boundary. There MUST be at least two deltas to form a boundary (with 4 vertices). When specifying the deltas, the origin 0,0 and the last delta (to close the boundary) are implied and therefore omitted. e.g deltas=100,0,0,100,-100,0 defines a square of length 100.

• Alongside deltas, pos is the location where the first instance of the boundary is to be placed

• Alternately, one can specify the co-ordinates of the boundary using an x,y list xy=

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.
  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.path

xxxxxxxxxx
cadwriter.path
  $writer={writer_id}
  {{deltas={dx0},{dy0},{dx1},{dy1}[,{dx},{dy}]* pos={x},{y}} | xy={x1},{y1}..{xn},{yn}}
  width={path_width}
  [type={FLUSH | HALF | ROUND}]
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [layer={layer}:{datatype}]

• Write a path to the current cell (with or without repetitions)

• All co-ordinates are in file units

• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object

• deltas is a list of offsets from the path origin 0,0 that form the vertices of the path. There MUST be at least one delta to form a path (with 2 vertices). When specifying the deltas, the origin 0,0 is implied and therefore omitted. e.g deltas=100,0 defines a one-segment horizontal path of length 100 units.

• Alongside deltas, pos is the location where the first instance of the boundary is to be placed

• Alternately, one can specify the co-ordinates of the path using an x,y list xy=

• {path_width} MUST be specified (> 0.0)

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

• type if specified represents the path type. Default: FLUSH

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.
  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.circle

xxxxxxxxxx
cadwriter.circle
  $writer={writer_id}
  circle={x},{y},{radius},{arcres},{arcsag}
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [layer={layer}:{datatype}]

• Write a circle (converted to a polygon) to the current cell (with or without repetitions)

• All co-ordinates are in file units

• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object

• {x},{y} are the co-ordinates of the center, {arcres} and {arcsag} specify the fineness of the approximation of the polygon w.r.t the circle

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.
  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.reference

xxxxxxxxxx
cadwriter.reference
  $writer={writer_id}
  name={cellname}
  pos={x},{y}
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [scale={scale}]
  [angle={degrees}]
  [flipy]

• Write a cell reference to the current cell (with or without repetitions)

• All co-ordinates are in file units

• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object

• {cellname} is name of the cell to be referenced

• pos is the location where the first instance of the boundary is to be placed

• {scale} , {angle} and flipy if specified apply transformation to the reference

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.
  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.end_cell

cadwriter.end_cell $writer={writer_id}

• Close a cell definition
• {writer_id} is name of a variable of type QisMCADWriterV2* associated with an open writer object

cadwriter.close

cadwriter.close $writer={writer_id}

• Close a GDSII/OASIS composer
• {writer_id} is name of a variable of type QisMCADWriterV2* associated with the writer object to be closed

QisMRTCR commands

• Requires the QisMRTCR extension to be installed and loaded (qismrtcr64.dll/so)

• Select commands may require a valid license

• See qismrtcr.h for the corresponding API

• Learn more about QisMRTCR

  xxxxxxxxxx
  /* C++ code to get access to QisMRTCR extension API */
  #include "qismlib.h"
  #include "qismrtcr.h"
  using namespace NsQisMLib;
  using namespace NsQisMRTCR;
  ​
  bool rtcr_get_extension_api(QisMLib* qismlib, QisMRTCR*& rtcr_api)
  {
    assert(qismlib != NULL);
    QisMExtensionAPI* extn = qismlib->Get_extension_api(QISMEXTENSION_RTCR);
    if(!extn) {
      fprintf(stderr, "error: failed to locate extension '%s'", QISMEXTENSION_RTCR);
      return false;
    }
    rtcr_api = (QisMRTCR*)(extn->Extension_class_ptr());
    return true;
  }
  

rtcr.create_opts

rtcr.create_opts &opts={opts_id} [layers={layer_filter}] [diskload] [keeptmp]

• Create a new instance of the basic RTCR options object (QisMRTCROpts*)

• Equivalent to QisMRTCR::Create_object("QisMRTCROpts") in qismrtcr.h

• {opts_id} represents name of the variable of type QisMRTCROpts* associated with the newly created object

• {layer_filter} if used, can be a comma-separated list of layers w/o datatypes OR a layer map

  • e.g "1,2:2,3" for a simple list of layers of interest
  • e.g "ALL-NULL,1-100,2:2-200:0,3-300:3" for a layer map that re-maps 1:* to 100:*, 2:2 to 200:0 and merges all datatypes of layer 3 to 300:3

• diskload if used creates the new database in 'disk' mode to reduce the memory footprint

• keeptmp if used will retain the temporary files used by an RTCR job in it's job directory after the job has been closed. This can be useful for troubleshooting and diagnosis

• Every object created using this command MUST be destroyed by the script using rtcr.destroy_opts to avoid resource leak

  xxxxxxxxxx
  /* C++ equivalent of rtcr.create_opts */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  bool rtcr_create_opts(
    QisMRTCR* rtcr_api, const char* layers, const bool diskload, const bool keeptmp,
    QisMRTCROpts*& handle
    )
  {
    assert(rtcr_api != NULL);
    
    handle = (QisMRTCROpts*)(rtcr_api->Create_object("QisMRTCROpts"));
    assert(handle != NULL);
    
    if(layers && layers[0]) handle->Set_layers(layers);
    handle->Set_load_from_disk(diskload);
    handle->Set_keep_working_files(keeptmp);
    return true;
  }
  

rtcr.destroy_opts

rtcr.destroy_opts $opts={opts_id}

• Destroy an instance of the basic RTCR options object

• Equivalent to QisMRTCR::Destroy_object("QisMRTCROpts") in qismrtcr.h

• {opts_id} represents name of the variable of type QisMRTCROpts* associated with the object to be destroyed

  xxxxxxxxxx
  /* C++ equivalent of rtcr.destroy_opts */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  void rtcr_destroy_opts(QisMRTCR* rtcr_api, QisMRTCROpts* opts)
  {
    assert(rtcr_api != NULL);
    if(opts) rtcr_api->Destroy_object("QisMRTCROpts", opts);
  }
  

rtcr.create_corrections

xxxxxxxxxx
rtcr.create_corrections 
  &corr={corr_id} 
  {{point={x},{y},{dx},{dy}}+4x} | file={corr_file} 
  [tolerance={value}]

• Create an instance of the RTCR corrections object

• Equivalent to QisMRTCR::Create_object("QisMRTCRCorrections") in qismrtcr.h

• {corr_id} represents name of the variable of type QisMRTCRCorrections* associated with the newly created object

• {x},{y},{dx},{dy} represents one correction point. Each domain contains exactly FOUR such points. Specify one or more domains using a series of point= arguments

• {corr_file} represents the path of a correction text file to be imported. See QisMRTCRCorrections in qismrtcr.h for file syntax

• {value} represents the amount of tolerance to be applied for correcting cell references

• Every object created using this command MUST be destroyed by the script using rtcr.destroy_corrections to avoid resource leak

  xxxxxxxxxx
  /* C++ equivalent of rtcr.create_corrections */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  struct CorrectionPt
  {
    double x, y, dx, dy;
    CorrectionPt(): x(0.0), y(0.0), dx(0.0), dy(0.0) {}
  };
  ​
  bool rtcr_create_corrections(
    QisMRTCR* rtcr_api, const char* file, const CorrectionPt* points, 
    const int n_points, const double tolerance, QisMRTCRCorrections*& corr
    )
  {
    assert(rtcr_api != NULL);
    
    corr = (QisMRTCRCorrections*)(rtcr_api->Create_object("QisMRTCRCorrections"));
    assert(corr != NULL);
    
    if(file && file[0]) {
      int ecode = corr->Add_from_file(file);
      if(ecode != 0) {
        fprintf(
          stderr, "error: failed to apply '%s', %s", file, corr->Get_error_msg(ecode)
          );
        return false;
      }
    }
    
    if(points && (n_points > 0)) {
      if((n_points % 4) != 0) {
        fprintf(stderr, "error: each correction domain contains exactly FOUR points");
        return false;
      }
      for(int p=0; p<n_points; p+=4) {
        corr->Add_domain(
          points[p+0].x, points[p+0].y, points[p+0].dx, points[p+0].dy,
          points[p+1].x, points[p+1].y, points[p+1].dx, points[p+1].dy,
          points[p+2].x, points[p+2].y, points[p+2].dx, points[p+2].dy,
          points[p+3].x, points[p+3].y, points[p+3].dx, points[p+3].dy
          );
      }
    }
    
    corr->Set_tolerance(tolerance);
    return true;
  }
  

rtcr.destroy_corrections

rtcr.destroy_corrections $corr={corr_id}

• Destroy an instance of the RTCR corrections object

• Equivalent to QisMRTCR::Destroy_object("QisMRTCRCorrections") in qismrtcr.h

• {corr_id} represents name of the variable of type QisMRTCRCorrections* associated with the object to be destroyed

  xxxxxxxxxx
  /* C++ equivalent of rtcr.destroy_corrections */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  void rtcr_destroy_corrections(QisMRTCR* rtcr_api, QisMRTCRCorrections* corr)
  {
    assert(rtcr_api != NULL);
    if(corr) rtcr_api->Destroy_object("QisMRTCRCorrections", corr);
  }
  

rtcr.create_annotations

rtcr.create_annotations &ann={ann_id} [file={ann_file}]

• Create an instance of the RTCR annotations object

• Equivalent to QisMRTCR::Create_object("QisMRTCRAnnotations") in qismrtcr.h

• {ann_id} represents name of the variable of type QisMRTCRAnnotations* associated with the newly created object

• {ann_file} if specified, represents the path of a annotation text file to be imported. See QisMRTCRAnnotations in qismrtcr.h for file syntax

• Every object created using this command MUST be destroyed by the script using rtcr.destroy_annotations to avoid resource leak

  xxxxxxxxxx
  /* C++ equivalent of rtcr.create_annotations */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  bool rtcr_create_annotations(
    QisMRTCR* rtcr_api, const char* file, QisMRTCRAnnotations*& ann
    )
  {
    assert(rtcr_api != NULL);
    
    ann = (QisMRTCRAnnotations*)(rtcr_api->Create_object("QisMRTCRAnnotations"));
    assert(ann != NULL);
    
    int ecode = ann->Add_from_file(file);
    if(ecode != 0) { 
      fprintf(
        stderr, "error: failed to apply '%s', %s", file, ann->Get_error_msg(ecode)
        );
      return false;
    }
    return true;
  }
  

rtcrannotations.add

xxxxxxxxxx
rtcrannotations.add
  $ann={id}
  text={string}
  {pos={x},{y},{height} | box={lx},{ly},{ux},{uy}}
  units_m={value}
  [angle={degrees}]
  [margin={mm_value}]
  [inverse]
  [frame]
  [backwards]

• Add one annotation item to a list of annotations. This command can be called multiple times to add more annotations to a single job
• {id} is name of a variable of type QisMRTCRAnnotations* associated with the annotations settings object obtained via rtcr.create_annotations
• {string} is the annotation text
• {x},{y},{height} are the position and size of the annotation in file units. The width is calculated based on the text string and the height. Alternately, the annotation can be fit into a fixed size bounding box with min-max extents {lx} .. {uy}. One of these two options MUST be specified
• units_m is the file units in meters. e.g um = 1e-6
• angle is the rotation to be applied to the text. In box mode, the rotated text is made to fit inside the specified box. The box itself is not rotated
• margin is the amount of margin (in mm) to be applied between the text and the outer frame when frame is enabled
• frame if specified places the text inside a frame
• inverse if specified inverts the polarity of the text polygons (the text is subtracted from a base rectangle)
• backwards if specified reverses the appearance of the text so that it reads backwards

rtcr.destroy_annotations

rtcr.destroy_annotations $ann={ann_id}

• Destroy an instance of the RTCR annotations object

• Equivalent to QisMRTCR::Destroy_object("QisMRTCRAnnotations") in qismrtcr.h

• {ann_id} represents name of the variable of type QisMRTCRAnnotations* associated with the object to be destroyed

  xxxxxxxxxx
  /* C++ equivalent of rtcr.destroy_annotations */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  void rtcr_destroy_annotations(QisMRTCR* rtcr_api, QisMRTCRAnnotations* ann)
  {
    assert(rtcr_api != NULL);
    if(ann) rtcr_api->Destroy_object("QisMRTCRAnnotations", ann);
  }
  

rtcr.setup_job

xxxxxxxxxx
rtcr.setup_job
  &job={job_id} 
  outdir={output_dir}
  input={input_gdsii}
  [$opts={opts_id}] 
  [$corr={corr_id}] 
  [$ann={ann_id}]

• Create a new RTCR job and a new database associated with it

• Equivalent to QisMRTCR::Setup_job in qismrtcr.h

• Requires 1 license of (1303) which will be released during rtcr.end_job

• RTCR job represents a database created from a micron (um) GDSII file optionally with corrections and annotations

• {job_id} represents name of the variable of type QisMRTCRJob* associated with the newly created job

• {output_dir} is the path of an existing directory to be used as a working directory for this job

• {input_gdsii} is the path of the source GDSII file. It MUST has micron units. Usually, it would be generated by SFGen

• {opts_id} if used, represents name of the variable of type QisMRTCROpts* associated with the RTCR basic options object created using rtcr.create_opts

• {corr_id} if used, represents name of the variable of type QisMRTCRCorrections* associated with RTCR corrections object created using rtcr.create_corrections

• {ann_id} if used, represents name of the variable of type QisMRTCRAnnotations* associated with RTCR annotations object created using rtcr.create_annotations

• Every job created using this command MUST be eventually destroyed using rtcr.end_job to avoid resource leaks

• This command also creates a new script variable of type QisMFile* with the name {job_id} so that it can be used wherever QisMFile can be used. DO NOT use this variable with lib.unload_file as the associated database will be destroyed automatically during rtcr.end_job

  xxxxxxxxxx
  /* C++ equivalent of rtcr.setup_job */
  #include "qismlib.h"
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  using namespace NsQisMLib;
  ​
  class ProgressCb: public QisMNotify
  {
  public:
    void* QisMNotify_cast(const int version) {
      switch(version) {
        case 0: return this;
        case 1: return dynamic_cast<QisMNotify*>(this);
      }
      return 0;
    } 
    const void* QisMNotify_cast(const int version) const {
      switch(version) {
        case 0: return this;
        case 1: return dynamic_cast<const QisMNotify*>(this);
      }
      return 0;
    }
    int QisMNotify_latest_version() const { return 1; }
    
    int On_qismt_progress(
      const char* pre, const char* msg, const char* post
      )
    {
      if(msg && msg[0]) {
        fprintf(stdout, "%s%s%s", pre ? pre : "", msg, post ? post : "");
      }
      return 0;
    }
  };
  ​
  bool rtcr_setup_job(
    QisMRTCR* rtcr_api, QisMLib* qismlib, const char* outdir, const char* input,
    QisMRTCROpts* opts, QisMRTCRCorrections* corr, QisMRTCRAnnotations* ann,
    QisMRTCRJob*& job
    )
  {
    assert(rtcr_api != NULL);
    assert(qismlib != NULL);
    assert(outdir && outdir[0]); //outdir is a valid directory
    assert(input && input[0]); //input is a valid GDSII file
    
    ProgressCb progress_cb;
    int ecode = rtcr_api->Setup_job(
      job, outdir, qismlib, input, opts, dynamic_cast<QisMNotify*>(&progress_cb),
      corr, ann
      );
    if(ecode != 0) {
      fprintf(stderr, "error: failed to setup job, %s", rtcr_api->Get_error_msg(ecode));
      return false;
    }
    return true;
  }
  

rtcr.end_job

rtcr.end_job $job={job_id}

• Destroy an RTCR job and the database associated with it

• Equivalent to QisMRTCR::End_job in qismrtcr.h

• Releases 1 license of (1303) acquired during rtcr.setup_job

• {job_id} represents name of the variable of type QisMRTCRJob* associated with the job to be destroyed

  xxxxxxxxxx
  /* C++ equivalent of rtcr.end_job */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  void rtcr_end_job(QisMRTCR* rtcr_api, QisMRTCRJob* job)
  {
    assert(rtcr_api != NULL);
    if(job) rtcr_api->End_job(job);
  }
  

rtcrjob.create_rasterizer

xxxxxxxxxx
rtcrjob.create_rasterizer
  $job={job_id}
  &rstr={rasterizer_id}
  {pixelsize={x}[,{y}] | dpi={x}[|{y}]}
  [cell={cellname}] 
  [layers={std_layers}] 
  [dlayers={dither_layers}]
  [dither={0.0-1.0}] 
  [thrnum={num_threads}]
  {correct={x},{y},{dx},{dy}}*

• Create a new rasterizer object associated with a particular RTCR job

• Equivalent to QisMRTCRJob::Create_rasterizer in qismrtcr.h

• Requires 1 license of (14827) per call which will be released during rtcrjob.destroy_rasterizer

• {job_id} represents name of the variable of type QisMRTCRJob* associated with the newly created job

• {rasterizer_id} represents name of the variable of type QisMRTCRasterizer* associated with the newly created rasterizer object

• {x},{y} represents the desired image resolution in DPI (dots per inch) or as a pixel size (in file units). The {y} value is optional. If not used, the resolution is uniform along X and Y axes

• {cellname} is name of the view cell. If not used, the default top cell is used as the view cell

• {std_layers} is a comma-separated list of layers representing the layers to be rasterized in each image. If not used, ALL layers in the database as rasterized in each image. e.g layers=1,2:2,3:0,3:3,4

• {dither_layers} is a comma-separated list of layers to be rasterized with the specified dither value. If not used, dithering is disabled for the subsequent images. Dithering is applied using a 8x8 bayer matrix

• {num_threads} is the number of threads to be used to generate each raster image

• Use one or more correct={x},{y},{dx},{dy} to apply second-level corrections to any image generated using this rasterizer object. By default, no additional corrections are applied to rasterized images. Applying second-level corrections requires 1 license of (11093) in addition to (14827) per rasterizer object

• Each rasterizer created using this command MUST be destroyed eventually using rtcrjob.destroy_rasterizer to avoid resource leaks

  xxxxxxxxxx
  /* C++ equivalent of rtcrjob.create_rasterizer */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  bool rtcrjob_create_rasterizer(
    QisMRTCRJob* job, const double dpi_x, const double dpi_y, const char* cell, 
    const char* layers, const char* dlayers, const double dither, const int thrnum, 
    QisMRTCRasterizer*& rstr
    )
  {
    assert(job != NULL);
    
    double pixelsize_x = job->DPI_to_pixelsize(dpi_x);
    double pixelsize_y = job->DPI_to_pixelsize(dpi_y);
    int ecode = 0;
    rstr = job->Create_rasterizer(
      &ecode, pixelsize_x, pixelsize_y, cell, layers, dlayers, dither, thrnum
      );
    if(!rstr) {
      fprintf(
        stderr, "error: failed to create rasterizer, %s", job->Get_error_msg(ecode)
        );
      return false;
    }
    return true;
  }
  

  xxxxxxxxxx
  /* C++ equivalent of rtcrjob.create_rasterizer with second-level corrections */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  bool rtcrjob_create_rasterizer_corrx(
    QisMRTCRJob* job, const double dpi_x, const double dpi_y, const char* cell, 
    const char* layers, const char* dlayers, const double dither, const int thrnum, 
    const double* correction_pts_xy, const int n_pts
    QisMRTCRasterizer*& rstr
    )
  {
    assert(job != NULL);
    QisMRTCRJobV2* jobv2 = (QisMRTCRJobV2*)(job->QisMRTCRJob_cast(2));
    if(jobv2 == NULL) {
      fprintf(stderr, "error: feature not supported. requires QisMRTCRJobV2");
      return false;
    }
    
    double pixelsize_x = job->DPI_to_pixelsize(dpi_x);
    double pixelsize_y = job->DPI_to_pixelsize(dpi_y);
    int ecode = 0;
    rstr = jobv2->Create_corrx_rasterizer(
      &ecode, pixelsize_x, pixelsize_y, correction_pts_xy, n_pts, cell, layers, dlayers, 
      dither, thrnum
      );
    if(!rstr) {
      fprintf(
        stderr, "error: failed to create rasterizer, %s", jobv2->Get_error_msg(ecode)
        );
      return false;
    }
    return true;
  }
  

rtcrjob.destoy_rasterizer

rtcr.destoy_rasterizer $job={job_id} $rstr={rasterizer_id}

• Destroy a rasterizer object

• Equivalent to QisMRTCRJob::Destroy_rasterizer in qismrtcr.h

• Releases 1 license of (14827) acquired during rtcrjob.create_rasterizer

• {rasterizer_id} represents name of the variable of type QisMRTCRasterizer* associated with the rasterizer to be destroyed

• {job_id} represents name of the variable of type QisMRTCRJob* associated with the job that created the rasterizer in question

  xxxxxxxxxx
  /* C++ equivalent of rtcr.destroy_rasterizer */
  #include "qismrtcr.h"
  using namespace NsQisMRTCR;
  ​
  void rtcrjob_destroy_rasterizer(QisMRTCRJob* job, QisMRTCRasterizer* rstr)
  {
    assert(job != NULL);
    if(rstr) job->Destroy_rasterizer(rstr);
  }
  

rtcrjob.get_raster_image

xxxxxxxxxx
rtcrjob.get_raster_image
  $job={job_id} 
  $rstr={rasterizer_id}
  $windows={window_set_id}
  [invert] 
  [right_to_left] 
  [shiftpx={INS_B | INS_W | REM}]
  [pxrows={px}[,{px}]*] 
  [pxcols={px}[,{px}*]] 
  [format={TIF | BMP | RAW}]

• Generate one or more raster images

• Equivalent to multiple calls to QisMRTCRJob::Get_raster_image in qismrtcr.h

• {job_id} represents name of the variable of type QisMRTCRJob* associated with the job in question

• {rasterizer_id} represents name of the variable of type QisMRTCRasterizer* associated with the rasterizer to used for generating these images

• {window_set_id} represents name of the variable of type QisMBoxSet* associated with a set of windows created using script.new_window_set

• invert is used, inverts the image polarity to white-on-black i.e bit=0 for data, bit=1 for background

• right_to_left rasterizes the image from right to left i.e min-x of the data appears on the right hand size of the raster image

• shiftpx, pxrows and/or pxcols is used, apply row/column shifting to each image. {px} represents a row/column number in pixel space (MUST be within the bounds of the image). pixel 0,0 appears at the top-left corner of the image. INS_B inserts a black line (white line in invert mode), INS_W inserts a white line (black line in invert mode) and REM removes a line. The image size does not change in either case

• format is used writes the image to disk in TIFF, BMP or RAW format. The job directory is used as the output directory. The name of each file is derived from the associated window-name (see script.new_window_set)

  xxxxxxxxxx
  /* C++ equivalent of rtcr.get_raster_image */
  #include "qismbase.h"
  #include "qismrtcr.h"
  #include "qismraster.h"
  using namespace NsQisMLib;
  using namespace NsQisMRTCR;
  using namespace NsQisMRaster;
  ​
  bool rtcr_get_raster_image(
    QisMRTCRJob* job, QisMRTCRasterizer* rstr, const QisMBoxSet* windows, 
    const bool invert, const bool right_to_left, 
    const QisMRTCRFlags::Shift_type shiftpx, const int n_cols, 
    const long long* pxcols, const int n_rows, const long long* pxrows
    )
  {
    assert(job != NULL);
    assert(rstr != NULL);
    assert(windows != NULL);
    
    int n_windows = windows->Get_count();
    for(int w=0; w<n_windows; w++)
    {
      double lx = 0.0, ly = 0.0, ux = 0.0, uy = 0.0;
      const char* name = windows->Get_box(w, lx, ly, ux, uy);
      assert(name != NULL);
      const QisMRasterImage* img = 0;
      int ecode = job->Get_raster_image(
        img, rstr, lx, ly, ux, uy, invert, right_to_left, shift_type, n_cols, pxcols,
        n_rows, pxrols
        );
      if(ecode != 0) {
        fprintf(
          stderr, "failed to rasterize window (%g, %g, %g, %g), %s", lx, ly, ux, uy, 
          job->Get_error_msg(ecode)
          );
        return false;
      }
      assert(img != NULL);
      fprintf(stdout, "%s\n", img->Report());
    }
    return true;
  }
  

QisMLayerSynth commands

• Requires the QisMLayerSynth extension to be installed and loaded (qismlayersynth64.dll/so)

• Select commands may require a valid license

• See qismlayersynth.h for the corresponding API

• Learn more about QisMLayerSynth

  xxxxxxxxxx
  /* C++ code to get access to the QisMLayerSynth API */
  #include "qismlib.h"
  #include "qismlayersynth.h"
  using namespace NsQisMLayerSynth;
  using namespace NsQisMLib;
  ​
  bool lsynth_get_extension_api(QisMLib* qismlib, QisMLayerSynth*& qismlsynth)
  {
    assert(qismlib != NULL);
    QisMExtensionAPI* extn = qismlib->Get_extension_api(QISMEXTENSION_QISMLSYNTH);
    if(!extn) {
      fprintf(
        stderr, "error: failed to locate extension '%s'", QISMEXTENSION_QISMLSYNTH
        );
      return false;
    }
    qismlsynth = (QisMLayerSynth*)(extn->Extension_class_ptr());
    return true;
  }