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

QisMLib Script Commands

Console (qismscript64.exe) commands

These commands are only applicable when using the scripting console (qismscript64.exe) to execute scripts or commands

usage.required

xxxxxxxxxx
usage.required {description}

• Report mandatory paramters for using a script (one per line)

• {description} is the appropriate description of the parameter

usage.option

xxxxxxxxxx
usage.option [{description}]

• Report optional paramters for using a script (one per line)

• {description} is the appropriate description of the parameter

usage.info

xxxxxxxxxx
usage.info {description}

• Report any additional information relevant to a script

• {description} is the appropriate information

sleep

xxxxxxxxxx
sleep 
  interval={interval_s}

• Sleep for the specified interval in seconds

assert

xxxxxxxxxx
assert
  key={name} 
  [msg={prompt}]

• Alternative to script.required

• Confirm that a string variable has been set. If not, exit the script with an error message

• key={name} identifies the variable in question

• [msg={prompt}] if specified will show up in the error message

• The error message will appear as error: missing {name} or error: missing {name}={ {prompt} }

askif

xxxxxxxxxx
askif 
  key={key} 
  [msg={message}]

• Check if the string variable {key} has been set. If not, prompt the user for a value

• {message} is the appropriate message to add to the prompt

system

xxxxxxxxxx
system {program} {args}*

• Execute an application or command provided by the system (or shell)

• {program} is the appropriate application/command to execute

• {args} are one or more paramters to pass per the application/command's usage

commands

xxxxxxxxxx
commands 
  [{search-string}]

• Get a list of available commands and it's paramters

• {search-string} if specified only lists commands whose name/paramter-list contain the search string

exit

xxxxxxxxxx
exit

• Terminate the execution of the script WITHOUT normally (without an error)

Basic (QisMScript) commands

Various utility commands that aid in the development of a script Available to all applications using the QisMLib system with scripting enabled

script.procedure

xxxxxxxxxx
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

xxxxxxxxxx
script.end_procedure

• Close the definition of the procedure in question

script.call

xxxxxxxxxx
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.push

xxxxxxxxxx
script.push {token}+

• Add one or more tokens to a list of tokens that will be passed to every subsequent command

script.pop

xxxxxxxxxx
script.pop [{token}]

• Remove the specified token from the list of tokens that will be passed to every subsequent command

• If no token is specified, the entire list is cleared

script.required

xxxxxxxxxx
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.if

xxxxxxxxxx
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}

  • {key}~!{value} : TRUE if a string variable called {key} DOES NOT CONTAIN the string {value}

  • {key1}|{key2}...|{keyn} : TRUE if at least one of the {key1...n} are defined

  • {key1}&{key2}...&{keyn} : TRUE if all of the {key1...n} are defined

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

script.set

xxxxxxxxxx
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

xxxxxxxxxx
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.ifset

xxxxxxxxxx
script.ifset {{key}={value}}+

• Assign a value to one or more string variable ONLY IF that variable already has a value

• Subsequently referencing that string variable elsewhere in the script using (({key})) will return the new value

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.branch

xxxxxxxxxx
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.foreach

xxxxxxxxxx
script.foreach
  &token={var_name} 
  {loop={from},{to},{increment}} | {list={list_of_tokens} | file={token_file}}
  {branch={script_file_path} | call={procedure_name}}
  [sep={separator}] 
  [{key}={value}]*

• Execute a loop for each item in a list of items

• loop= creates a for loop starting with an integer {from} upto {to} with a step of {increment}. On each run, the specified token is assigned the value of the for iterator. If {increment} is positive, the test is {from} <= {to}. Otherwise, the test is {from} >= {to}

• Alternately list={list_of_tokens} creates a loop based on a string containing one or more tokens separated by separators. On each run, the specified token is assigned the current item from the list

• Alternately, file={token_file} creates a loop based on a list of items in a text file, one item per line. On each run, the specified token is assigned the item at the current line

• {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.convert

xxxxxxxxxx
script.convert
  from={spec} 
  to={spec} 
  values={list} 
  [&var={id}] 

• Convert a comma-separated list of values from one unit to another

• {spec} can be one of the following :-

  • m

  • cm

  • mm

  • um

  • nm

  • in

  • mils

  • dpi

  • dbu,{db_id}

  • uu,{db_id}

• For dpi conversions, the value to be converted is implied to be the pixel-size (or the dot-size)

• {db_id} is a variable of type QisMFile* representing the database in question. dbu is the database-unit and uu is the user-unit of that database

• values provides a comma-separated list of values in the source (from) units

• scale if specified multiplies the result with the specified value

• &var if specified will add a new string variable represented by {id} containing a comma-separated list of results

• E.g --

  • from=um to=dpi values=1 will result in 25400. I.e a pixel of size 1um is equivalent to 25400 dots-per-inch

  • from=mm to=um values=1,0.001 will result in 1000,1

  • For a UM db F with NM resolution (units = 1e-6 m and grid = 1e-9 m),

    • from=uu,F to=dpi values=1 will result in 25400 (1um = 25400dpi)

    • from=dpi to=dbu,F values=25400 will result in 1000 (25400dpi = 1000nm)

script.rename

xxxxxxxxxx
script.rename $old={old_id} type={type_name} $new={new_id}

• Move a script variable of name {old_id} and type {type_name} to a new name {new_id}

• The old id for the specified type will cease to exist from this point on

• The type remains the same

• CAUTION -- Any other dependent variables that were added alongside {old_id} such as {old_id}.{something} will continue to exist as is. Therefore, this command should be used sparingly and only when there is no other alternative solution

script.make_id

xxxxxxxxxx
script.make_id str={string} &id={id}

• Convert an arbitrary string {string} into another string {id} that is more suitable to be used as a script variable name

• Replaces most non-alphanumeric characters with an underscore or a hyphen

• Does not guarantee uniqeness. Two non-identical strings could potentially result in the same id

script.num_cpus

xxxxxxxxxx
script.num_cpus [&var={name}]

• Print the no. cpu(s) in the system

• If name is specified, the value is stored as a string variable by that name

script.file_name

xxxxxxxxxx
script.file_name 
  path={file_path} 
  [&dir={var}] 
  [&name={var}] 
  [&ext={var}]
  [&basename={var}]
  [&full={var}]

• Get various components of a file at the specified {file_path}

  • &dir if specified, retrieves the directory

  • &name if specified, retrieves the file name (with extension)

  • &ext if specified, retreives the extension

  • &basename if specified, retreives the name (without extension)

  • &full if specified, get the absolute full path

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

xxxxxxxxxx
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

xxxxxxxxxx
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

script.print_vars

xxxxxxxxxx
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

QisMLib Commands

See qismlib.h for the relevant C++ API

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)

lib.load_gds_with_mmaps

​x
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

xxxxxxxxxx
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

QisMFile commands

See qismfile.h for relevant C++ API

file.print_report

xxxxxxxxxx
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

file.get_default_cell

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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.print_cell_tree

xxxxxxxxxx
file.print_cell_tree $filedb={filedb_id} [cell={cellname}] [&var={name}] [sep={open}{close}{next}]

• 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

• [&var={name}] if used stores the entire cell hierarchy in a parser-friendly string variable of the specified name. In that case, [sep={open}{close}{next}] can be used to control the separators as follows --

  • {open} is a single character that indicates the start of sub-tree for the current cell. Default: {

  • {close} is a single character that indicates the end of the sub-tree for the current cell. Default: }

  • {next} is a single character that indicates the next cell at the same hierarchy. Defaul: ,

file.save_memory_maps

xxxxxxxxxx
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.create_exploder

xxxxxxxxxx
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

xxxxxxxxxx
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

QisMExploder commands

• see qismview.h and qismexploder.h for the relevant C++ 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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

QisMBStore commands

See qismbstore.h for relevant API

store.print_info

xxxxxxxxxx
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

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 | TIF8 | 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)

QisMDraw commands

See qismdraw.h for the corresponding C++ API

draw.image

xxxxxxxxxx
draw.image
  $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

See qismbool.h for the relevant C++ API

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}]
  [dbg={text_file}]

• 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

• dbg if specified generates a {text_file} with detailed information about the internal state of the boolean object

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

xxxxxxxxxx
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

QisMExplCounter commands

See qismexplcounter.h for the relevant C++ API

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} if specified, 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.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.delete_windows

xxxxxxxxxx
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 relevant C++ API

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

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

xxxxxxxxxx
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

xxxxxxxxxx
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

xxxxxxxxxx
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

QisMRaster Commands

• Requires the QisMRaster extension (qismraster64.dll/.so) to be installed, configured and loaded

• Some commands require a valid license (14827) to run

• Refer to qismraster.h for the corresponding C++ API

raster.create_rasterizer

xxxxxxxxxx
raster.create_rasterizer 
  &rstr={rstr_id} 
  $filedb={filedb_id}

• Create a new rasterizer object

• Requires 1 license of (14827) per call

• Equivalent to QisMRaster::Create_rasterizer

• {filedb_id} is name of a variable of type QisMFile* associated with the database linked to serve as the data source for the rasterizer

• {rstr_id} is name of the variable of type QisMRasterizer* to be associated with the newly created rasterizer object

• Every rasterizer object created with the command MUST be eventually destroyed using raster.destroy_rasterizer to avoid resource leaks

raster.destroy_rasterizer

raster.destroy_rasterizer $rstr={rstr_id}

• Destroy a rasterizer object

• Releases 1 license of (14827) acquired at creation

• Equivalent to QisMRaster::Destroy_rasterizer

raster.create_params

xxxxxxxxxx
raster.create_params
  &params={params_id} 
  pixelsize={x}[,{y}] 
  [invert]
  [dither={0.0_to_1.0}]
  [right_to_left]
  [bottom_to_top]
  [est_buffer_cnt={n_vertices}] 
  [no_patterns] 
  [thrnum={n_threads}]
  [fill={SOLID | OUTLINE}] 
  [format={TIF | BMP | VBMP | RAW}]
  [nesting={level}]
  [paths]

• Create an object to hold rasterization parameters

• Equivalent to QisMRaster::New_object("QisMRasterParams")

• {params_id} represents name of a variable of type QisMRasterParams* to be associated with the newly created object

• {x}[,{y}] represents the resolution for rasterization as size of a pixel along X and Y axes. If {y} is omitted, {x} is used along both axes

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

• dither if used applies dithering to the data areas using 8x8 bayer matrix

• right_to_left if used reverses the rasterization direction along X so that the first pixel of each row represents the max-x point in the data space. The last pixel represents the min-x point

• bottom_to_top is used reverses the rasterization direction along Y so that the first row of pixels represent the min-y points in the data space. The last row represents the max-y points

• {n_vertices} if used indicates the size of the polygon buffer when thrnum > 1 (multi-threaded rasterization). Default value is 1,000,000. If set to 0, multi-threading is disabled and each polygon is rasterized on-the-fly (same happens when {n_theads} == 1)

• no_patterns if used, disables cellular pattern recognition. i.e repeating cell data within the image space is NOT used for faster rasterization

• {n_threads} determines the number of threads used for rasterization. Default -- no. cpus

• fill if used controls the fill mode. Default -- SOLID

• format if used controls if the image is written to disk in the specified format after rasterization is complete. Default -- no writing to disk

• {level} if > 0 specifies the nesting level at which data is to be rasterized. This does not do anything in paint&scratch and layer synthesis modes. Also, if set, cellular pattern recognition will be disabled

• paths if specified allows PATH data to be rasterized separately instead of being converted to boundaries. This can be particulary useful for 0-width and 1-point paths

• !ellipses if specified disables native rasterization for circle/ellipse constructs in paint&scratch data

• Every object created using this command MUST be eventually destroyed using raster.destroy_params to avoid memory leak

raster.destroy_params

raster.destroy_params $params={params_id}

• Destroy an object that holds rasterization parameters

• Equivalent to QisMRaster::Delete_object("QisMRasterParams")

• {params_id} represents name of a variable of type QisMRasterParams* associated with the object to be destroyed

raster.window

xxxxxxxxxx
raster.window
  $rstr={rstr_id} 
  outbase={output_dir_and_name}
  $params={params_id} 
  {window={lx},{ly},{ux},{uy} | $windows={window_set_id}}
  [cell={cellname}] 
  [layers={layer_list}]
  [grayscale={sample_rate},{bpp} | subsample]

• Generate a monochrome bitmap from a view of the database

• Equivalent to QisMRasterizer::Rasterize_window

• {rstr_id} is name of the variable of type QisMRasterizer* associated with the a rasterizer object

• {output_dir_and_name} is the base path of the output image (directory + file name). The extension will be automatically added based on the format (.tif, .bmp or .raw). See raster.create_params

• {params_id} is name of a variable of type QisMRasterParams* containing the rasterization parameters. See raster.create_params

• {lx},{ly},{ux},{uy} is the extents of the window (in file units) for which the image is to be generated. Alternately a set of windows can be specified where {window_set_id} is name of a variable of type QisMBoxSet* (See script.new_window_set) representing a set of windows to be rasterized with the same parameters

• {cellname} if used is the name of the view cell. Default -- default top cell

• {layer_list} if used is a comma-separated list of layer(s) or layer:datatype(s) to be rasterized in this image

• If a format was specified, an image file will be created on disk at the specified base path

• grayscale if specified generates a gray scale image with the specified sampling rate (uniform sampling) and bits per pixel (bpp). Only the following gray scale modes are supported based on the output format:

  Format	{sample_rate},{bits_per_px}
  TIF, TIF8, NONE	2,2 2,4 2,8 4,4 4,8 8,8
  BMP, VBMP	2,4 2,8 4,4 4,8 8,8

raster.px_window

xxxxxxxxxx
raster.px_window
  $rstr={rstr_id} 
  outbase={output_dir_and_name}  
  $params={params_id} 
  extents={px_lx},{px_ly},{width_bytes},{height_px}  
  [cell={cellname}] 
  [layers={layer_list}] 
  [grayscale={sample_rate},{bpp}]

• Rasterize a window whose co-ordinates are specified in pixel space

• Equivalent to QisMRasterizerV4::Rasterize_px_window

• {rstr_id} is name of the variable of type QisMRasterizer* associated with the a rasterizer object

• {output_dir_and_name} is the base path of the output image (directory + file name). The extension will be automatically added based on the format (.tif, .bmp or .raw). See raster.create_params

• {params_id} is a name of a variable of type QisMRasterParams* associated with the rasterization parameters

• {px_llx},{px_lly} are the lower-left co-ordinates of the window in pixel space

• {width_bytes} is the image width in bytes

• {height_px} is the image height in pixels (or bytes)

• {cellname} if specified is the view cell (default: default top cell of the file)

• layers (if specified) is a comma-separated list of layers to be rasterized (default: ALL)

• pixel_coordinate = round(file_coordinate/pixelsize)

• If a format was specified, an image file will be created on disk at the specified base path

• grayscale if specified generates a gray scale image. See raster.window for details

raster.polys

xxxxxxxxxx
raster.polys
  $rstr={id}
  $bin={id}
  $params={id}
  [outbase={base_path}]
  [window={minx},{miny},{maxx},{maxy}]
  [repeat={x1},{y1}...{xn},{yn}]

• Rasterize a set of polygons

• $rstr points to a variable of type QisMRasterizer* representing the rasterizer object to be used

• $bin points to a variable of type QisMBStore* representing the polygon set to be rasterized

• $params points to a variable of type QisMRasterParams* representing the raster settings to be used

• outbase if specified, is the base path (dir+filename) of the output file (per the output format). default: image

• window if specified is the clipping window. default: all polygons are rasterized as-is

• repeat if specified is a list of offsets (x,y) where the entire set is repeated. The first offset is implied to be 0,0 w.r.t lower-left of the polygon set

• Makes use of Import_bstore and Rasterize_polygon_set

raster.overlay_polys

raster.overlay_polys $rstr={rstr_id} $bin={bin_id} [mode={PAINT | SCRATCH | DITHER}]

• Overlay a set of polygon on an existing image (in the raster buffer)

• Equivalent to QisMRasterizerV2::Overlay_polygon_set from qismraster.h

• This command will only work after an image has been generated using raster.window or raster.synthesized

• {rstr_id} is name of the variable of type QisMRasterizer* associated with the a rasterizer object

• {bin_id} is name of the variable of type QisMBStore* associated with a set of polygons. It can be obtained using various other commands such as exploder.get_boundaries

• mode if used specified the overlay mode. Default -- DITHER (overlay polygons with the same dither value as the underlying image). PAINT causes the overlay to be solid regardless of the dither value of the underlying image. SCRATCH causes the overlay to be etched out (cleared) from the underlying image

• If a format was specified, an image file will be created on disk to overwrite the original image

raster.synthesized

xxxxxxxxxx
raster.synthesized
  $rstr={rstr_id} 
  outbase={output_dir_and_name}
  $params={params_id} 
  {window={lx},{ly},{ux},{uy} | $windows={window_set_id}}
  [cell={cellname}] 
  lsynth={lsynth_spec}
  [grayscale={sample_rate},{bpp}]

• Generate monochrome bitmap from the result of layer synthesis

• Equivalent to QisMRasterizer::Rasterize_window_synthesized

• {rstr_id} is name of the variable of type QisMRasterizer* associated with the a rasterizer object

• {output_dir_and_name} is the base path of the output image (directory + file name). The extension will be automatically added based on the format (.tif, .bmp or .raw). See raster.create_params

• {params_id} is name of a variable of type QisMRasterParams* containing the rasterization parameters. See raster.create_params

• {lx},{ly},{ux},{uy} is the extents of the window (in file units) for which the image is to be generated. Alternately a set of windows can be specified where {window_set_id} is name of a variable of type QisMBoxSet* (See script.new_window_set) representing a set of windows to be rasterized with the same parameters

• {cellname} if used is the name of the view cell. Default -- default top cell

• {lsynth_spec} specifies the expression to be used for layer synthesis. See here for syntax

• If a format was specified, an image file will be created on disk at the specified base path

• grayscale if specified generates a gray scale image. See raster.window for details

raster.create_pns_v2_spec

raster.destroy_pns_v2_spec

xxxxxxxxxx
raster.create_pns_v2_spec
  $rstr={rstr_id} 
  &spec={spec_id} 
  [cell={name}] 
  pxsize={x},{y}  
  [window={lx},{ly},{ux},{uy}]

raster.destroy_pns_v2_spec
  $rstr={rstr_id}
  $spec={spec_id}

• Create (or destroy) a paint & scratch specification (v2-cell based) for rasterizing paint & scratch data from a cell-based paint and scratch database

• Equivalent to QisMRasterizerV4::Create_paint_scratch_v2_spec / Destroy_paint_scratch_v2_spec

• {rstr_id} is name of the variable of type QisMRasterizer* associated with the a rasterizer object

• {spec_id} is name of a variable of type QisMRasterPSInfo_p to be associated with the newly created spec.

• {name} (if specified) is the cell to be rasterized

• {x},{y} is the resolution in pixel-size (file units)

• {lx}..{uy} if specified is the window if interest (in file units)

• Every spec. created this way MUST be eventually destroyed using raster.destroy_pns_v2_spec to avoid memory leaks

raster.window_pns_v2

xxxxxxxxxx
raster.window_pns_v2
  $rstr={rstr_id} 
  outbase={output_dir_and_name}  
  $params={params_id} 
  {window={lx},{ly},{ux},{uy} | $windows={window_set_id}}  
  [cell={cellname}] 
  [$spec={spec_id}] 
  [layers={layer_string}]
  [grayscale={sample_rate},{bpp}]

• Rasterize a window of a paint and scratch (v2-cell based) database

• Equivalent to QisMRasterizerV4::Rasterize_window_paint_scratch_v2

• {rstr_id} is name of the variable of type QisMRasterizer* associated with the a rasterizer object

• {output_dir_and_name} is the name associated with this raster image. It will be used as the base path (directory + filename) if this image is written to disk as TIFF/BMP/RAW

• {params_id} is a name of a variable of type QisMRasterParams* associated with the rasterization parameters

• {lx} .. {uy} are the lower-left and upper-right co-ordinates of the window to be rasterized (in file units)

• OR {window_set_id} is name of a variable of type QisMBoxSet* associated with the set of windows to be rasterized

• {cellname} (if specified) is the name of the cell to be rasterized. (default: the deepest top cell in the file)

• {spec_id} (if specified) is name of a variable of type QisMRasterPSInfo_p associated with the spec. (default: spec will be computed internally)

• layers if specified is a comma-separated list of layer(s) or layer:datatype(s) to be rasterized. Default: ALL

• If a format was specified, an image file will be created on disk at the specified base path

• grayscale if specified generates a gray scale image. See raster.window for details

raster.format_image

xxxxxxxxxx
raster.format_image
  $img={id} 
  outbase={base_path} 
  format={TIF8 | TIF | BMP | VBMP | RAW} 
  [thrnum={n}]

• Create a formatted file on disk from the specified image buffer

• {id} is the name of the rasterizer that holds the image buffer

• {base_path} is the dir + filename of the output file. The extension will be added automatically depending on the format

• {n} is the no. threads to be used for the formatting

• Equivalent to Format_image

raster.queue_mt

xxxxxxxxxx
raster.queue_mt
  $filedb={filedb_id}
  $windows={window_set_id}
  $params={raster_params_id}
  basepath={image_base_path}
  [cell={cellname}]
  [layers={layer_string}]
  [thrnum_win={n_window_threads}]
  [grayscale={sample_rate},{bpp}]
  [p&s]

• Use a multi-threaded queue to rasterize multiple windows in parallel

• Equivalent to QisMRasterV3::Rasterize_win_queue_mt or QisMRasterV4::Raster_win_queue_mt_paint_scratch_v2

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

• {window_set_id} is name associated with a variable of type QisMBoxSet* associated with a list of rectangular windows

• {raster_params_id} is name associated with a variable of type QisMRasterParams* associated with the raster settings object

• {image_base_path} is the base path (directory + base-name) of the images. A suffix of the format .{number} will be added where {number} is the position of the window in the list. The file extension will be automatically added based on the specified format

• {cellname} if specified sets the view cell. Default view cell is the deepest top cell

• {layer_string} if specified sets the view layers. Default all layers are ON

• {n_window_threads} if specified sets the number of windows to be processed simultaneously. Each window thread will require 1 license of (14827) for rasterization. Default -- no. of processors in the system

• p&s if specified uses the paint and scratch model instead of the default paint-only model

• The number of threads to be user per image and other rasterization settings depends on the $params spec.

• grayscale if specified generates a gray scale image. See raster.window for details

raster.large_disk_image

xxxxxxxxxx
raster.large_disk_image
  $filedb={filedb_id} 
  window={lx},{ly},{ux},{uy}  
  $params={params_id} 
  bufsz={mb} 
  [overlap={px}] 
  [base={path}] 
  [cell={name}]  
  [layers={list}] 
  [thrnum={n}] 
  [alloc={rn}{rd}{sn}{sd}] 
  [grayscale={sample_rate},{bpp}]
  [p&s]

• Rasterize an image to disk that is too large to hold in a single buffer in memory

• Equivalent to QisMRasterV4::Rasterize_large_disk_image or QisMRasterV4::Rasterize_large_disk_image_paint_scratch_v2

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

• {lx}..{uy} are the extents of the window in file units

• {params_id} is name of a variable of type QisMRasterParams* containing the rasterization parameters. See raster.create_params

• {mb} is the buffer size to be used as a guide to control how much memory is allocated for rasterization (in Megabytes). See alloc= to understand how memory is allocated based on this parameter

• overlap= if specified is the amount of overlapping rows between bands in pixels (default: 10)

• base= if specified is the output dir+filename. (default: out)

• cell= if specified is the view cell to be rasterized (default: deepest top cell)

• layers= if specified is the comma-separated list of layers to be rasterized (default:ALL)

• thrnum= if specified is the number of bands to be rasterized in parallel threads (default: no. cpus)

• alloc= if specified is the allocation scheme to be used

  • Default: 2112

  • The allocation scheme is a 4-digit number of the format ABCD

  • The amount of memory to be allocated for rasterization is (A/B)*(bufsz_mb) while the amount of memory to be allocated for stitching the bands is (C/D)*(bufsz_mb)

  • The scheme can be used to find the optimal performance depending on whether the bottleneck is in the rasterization or the stitching

• p&s if specified uses the paint and scratch model instead of the default paint-only model

• If a format was specified, an image file will be created on disk at the specified base path

• grayscale if specified generates a gray scale image. See raster.window for details

raster.get_dpi

raster.get_pixelsize

raster.get_dpi pixelsize={x}[,{y}] [units_m={units_in_meter}] [&var={var_id}] raster.get_pixelsize dpi={x}[,{y}] [units_m={units_in_meter}] [&var={var_id}]

• Convert resolution from pixel size to dots per inch and visa-versa

• {x}[,{y}] is the image resolution in term of size of a pixel in file units (or dots per inch). Square pixel implied of {y} is omitted

• units_m if specified is the data units in meters. Default: 1e-6 (um)

• {var_id} if specified represents name of a string variable to be associated with the computed resolution in the format {res_x},{res_y}. It can be referenced subsequently in the script as (({var_id}))

raster.compute_buf_sz

xxxxxxxxxx
raster.compute_buf_sz
  size={width}[,{height}]
  pixelsize={x}[,{y}]

• Compute size of a raster image buffer based on the size of a pixel

• {width},[{height}] are the dimensions of the data window in file units. Square tile implied if {height} is omitted

• {x}[,{y}] is the image resolution in term of size of a pixel in file units. Square pixel implied of {y} is omitted

raster.compute_tile_sz

xxxxxxxxxx
raster.compute_tile_sz
  buf_mb={buf_size_mb}
  pixelsize={x}[,{y}]
  [roi={minx},{miny},{maxx},{maxy}]
  [&width={width_id}]
  [&height={height_id}]

• Compute the size of a tile (window of data) based on the estimated buffer size in Mb (1024 * 1024 bytes)

• {buf_sz_mb} is the estimated buffer size in Mb. to be filled with 1 bit pixels

• {x}[,{y}] is the resolution in terms of size of a pixel along X and Y (in file units)

• roi if specified determines the aspect ratio of the computed tile size. The aspect ratio of the tile is made to match that of the region of interest (in file units)

• {widht_id} , {height_id} if specified represents names of string variables to be associated with the computed width and height respectively. These can then be referenced subsequently in the script as (({width_id})) and (({height_id})) respectively

QisMLOA Commands

QisMScript Commands to define and add rich annotations (texts, bitmaps) to CAD data

• See qismloa.h for the corresponding C++ api

• Some commands require a license (QISMLOA - 4250)

loa.create_ann_set

xxxxxxxxxx
loa.create_ann_set
  &ann={id} 
  units={meter} 
  grid={meter} 
  [ttf_dir={path}] 
  [font_dir={path}] 
  [stroke_weight={value}] 
  [line_spacing={value}] 
  [slant={value}] 
  [aspect={value}] 
  [circularize={1 | 0}] 
  [arcres={deg}] 
  [chord_error={arc_recov},{chord_err}] 
  [pixel_size_factor={value}] 
  [buffer_persist={1 | 0}] 
  [union={off | on | cutline | butting}] 
  [sort_size={value}] 
  [out_layer={lnum}:{dnum}] 
  [thrnum={value}]

Create a new annotation set and associates it with a script variable name {id} of type QisMLOAset*

• Data units and grid MUST be specified in meter

• ttf_dir represents the directory containing the font files. By default, the env. variable ACSLIB_TTF_FONTDIR represents that directory

• font_dir represents the writeable directory to be used to create intermediate font files.If this is not used, the env. variable ACSLIB_FONTDIR MUST be set to such a directory. Otherwise, adding text annotations will fail

• stroke_weight sets the stroke weight for polygons generated from fonts with path data. The width of stroked text is 1/stroke_weight the height of the text.

• line_spacing sets the spacing (>0.001 user units) for annotation with multiple lines for text annotations

• slant sets the slant in degrees for the text annotations

• aspect sets the x/y aspect ratio for the text annotations

• circularize is a toggle to smooth out fonts with arcs. This works in conjunction with arcres and chord error

• arcres sets the arc resolution for a particular set. This setting will keep reconstituted arcs within a certain distance of the original arc. Works in conjunction with chord error

• chord_error sets the arc recovery and chord error values

• pixel_size_factor sets the pixel size conversion factor

• buffer_persist toggles if bitmaps added via a buffer will have the image buffer persist during the execution or not

• union sets the union mode for annotations

• sort_size sets the size interval which sorting will be triggered for entries

• out_layer sets the layer:datatype for the annotations in the output Set_to_stream

• thrnum sets the no. of threads to be used during Set_to_stream

• Requires and holds one license of QISMLOA (4250)

• Every annotation set created this way MUST be explicitly destroyed using loa.destroy_ann_set

loa.destroy_ann_set

xxxxxxxxxx
loa.destroy_ann_set $ann={id}

Destroys an annotation set represented by the script variable named {id} of type QisMLOAset*

• Releases the QISMLOA (4250) license held by this object

• C++ : QisMLOA::Delete_annotation_set

loa.add_ann_bitmap

xxxxxxxxxx
loa.add_ann_bitmap
  $ann={id} 
  file={path} 
  [translate={x},{y}]  
  [angle={deg},{x},{y}] 
  [mirror=x,{value}] 
  [mirror=y,{value}] 
  [invert={1 | 0}]  
  [scale={value}]

Add a bitmap based annotation item to the set

• {id} is the name of a script variable of type QisMLOAset* representing the annotation set

• The bitmap MUST be an Artwork RAW file at the specified {path}

• translate if specified moves the text to the specified location. Default: 0,0

• angle if specified rotates the text about a point {x},{y} by {deg} degrees. Default: no rotation

• mirror if specified reflects the text about x or y located at the specified line. Default: no mirroring

• invert if used (set to 1) inverts the rendered text polarity. Default: 0

• scale is used to scale the annotation uniformly by the specified amount

• All spatial values are file units

loa.add_ann_text

xxxxxxxxxx
loa.add_ann_text
  $ann={id} 
  text={str} 
  font={name} 
  height={value} 
  [translate={x},{y}]  
  [angle={deg},{x},{y}] 
  [mirror=x,{value}] 
  [mirror=y,{value}] 
  [invert={1 | 0}]  
  [justify={left | center | right},{top | middle | bottom | baseline}]  
  [border={margin},{frame}] 

Add a text string based annotation to the set

• {id} is the name of a script variable of type QisMLOAset* representing the annotation set

• {str} is a text string (single or multi-line)

• font specifies the font file name used to render this text

• height specifies the font height

• translate if specified moves the text to the specified location. Default: 0,0

• angle if specified rotates the text about a point {x},{y} by {deg} degrees. Default: no rotation

• mirror if specified reflects the text about x or y located at the specified line. Default: no mirroring

• invert if used (set to 1) inverts the rendered text polarity. Default: 0

• justify if specified sets a horizontal and vertical justification. Default: left, top

• border if specified adds a border of the specified thickness {frame} with a {margin} from the text. Default: no border

• All spatial values are file units

loa.create_ann_set_from_file

xxxxxxxxxx
loa.create_ann_set_from_file
  &ann={id} 
  file={txt_file_path} 
  units={meter} 
  grid={meter}

Create an annotation set from a file in an internal Artwork format (SFGen)

• &ann={id} specifies the name to be associated with the newly created annotation set

• file={txt_file_path} specifies the path of the spec. file to be imported

• units={meter} and grid={meter} specifies the data units and grid in meter

loaset.to_file

xxxxxxxxxx
loaset.to_file
  $ann={id} 
  file={path} 
  units={m} 
  grid={m}

Generate a GDSII file from the annotation set

• {id} is the name of a script variable of type QisMLOAset* representing the annotation set

• {path} is the path of the output GDSII

• units={m} and grid={m} is the file units and grid in meter

loa.merge_ann_with_db

xxxxxxxxxx
loa.merge_ann_with_db
  $filedb={id} 
  $ann={id} 
  out={base_path}  
  [viewcell={name}] 
  [top={name}] 
  [layers={str}] 
  [oasis | gdsii]

Merge annotation set with the specified db and create a new CAD file on disk

• {id} is the name of a script variable of type QisMLOAset* representing the annotation set

• {base_path} is the directory + filename of the output file. Extension .gds or .oas will be added based on the format

• viewcell is the name of the cell from the source db to become the top cell in the output. Default: deepest top cell in the source

• top is the name of the top cell in the output (if not to be the same as the viewcell which is the default)

• layers specifies the layers of interest (comma-separated list of lnum(s) and/or lnum:dnum(s)). Default: "ALL"

• oasis generates an OASIS file. gdsii is the default.

QisMCorrX Commands

QisMScript Commands to compute 2D affine and bi-linear transformations on CAD data

• See qismcorrx.h for the corresponding C++ api

• Some commands require a license

corrx.create_affine

Create a new affine transformation object

xxxxxxxxxx
corrx.create_affine
  &affine={id} 
  {translate={dx},{dy}}* 
  {scale={sx},{sy}}*  
  {rotate={deg}}* 
  {shear={shx},{shy}}* 
  {flip=X|Y|XY}* 
  {clear}*

• &affine={id} specifies a name to be associated with the newly created object

• translate=... if specified adds translation along X and Y in user-units

• scale=... if specified adds scaling along X and Y

• rotate=... if specified adds rotation in degrees

• shear=... if specified adds shearing along X and Y

• flip=... if specified adds reflection along X or Y or X and Y axes

• clear resets the transformation matrix

• The transformations can be specified in any order and any number of times for a cumulative effect

• Every object created by this command MUST be destroyed using corrx.destroy_affine

affine.set

Add transformations to the affine object

xxxxxxxxxx
affine.set
  $affine={id} 
  {translate={dx},{dy}}* 
  {scale={sx},{sy}}*  
  {rotate={deg}}* 
  {shear={shx},{shy}}* 
  {flip=X|Y|XY}* 
  {clear}*

• $affine={id} specifies the name associated with an existing affine object

• translate=... if specified adds translation along X and Y in user-units

• scale=... if specified adds scaling along X and Y

• rotate=... if specified adds rotation in degrees

• shear=... if specified adds shearing along X and Y

• flip=... if specified adds reflection along X or Y or X and Y axes

• clear resets the transformation matrix

• The transformations can be specified in any order and any number of times for a cumulative effect

affine.transform

Apply affine transformation to a set of points

xxxxxxxxxx
affine.transform
  $affine={id} 
  xy={x},{y}[,{x},{y}]* 
  [&var={name}]

• $affine={id} specifies the name associated with an existing affine object

• xy=... is the set of points to be transformed

• &var={name} if specified creates a string variable called {name} that stores the transformed values in the format {x0},{y0}...{xn},{yn}

affine.transform_bstore

Apply affine transformation to a set of boundaries

xxxxxxxxxx
affine.transform_bstore
  $affine={id} 
  $bin={id} 
  [grid={value}]

• $affine={id} specifies the name associated with an existing affine object

• $bin={id} specifies the name associated with the boundary set to be transformed

• [grid={value}] specifies the data grid in user-units (default: 1.0)

• This command changes the boundary set to the transformed self

corrx.destroy_affine

Destroy an affine object

xxxxxxxxxx
corrx.destroy_affine
  $affine={id}

• $affine={id} specifies the name associated with an existing affine object to be destroyed

corrx.create_opts

Create a settings object for use with corrx.create_corrx_obj

xxxxxxxxxx
corrx.create_opts
  &opts={opts_id} 
  [thrnum={n_threads}]  
  [bufcount={poly_buffer_cnt}] 
  [source={layer_offset}]

• &opts={opts_id} specifies a name to be associated with the newly created object

• thrnum=... if specified is the no. threads to be used for certain operations (default: no. cpu(s))

• bufcount=... if specified is the est. buffer size to hold polygons during certain operations (default: 65536)

• source=... if specified allocates storage for source polygons at the specified layer += {layer_offset} for certain operations

• Every object created by this command MUST be destroyed using corrx.destroy_opts