Memory usage is now reduced to less than half of the previous versions.
An average of 10% to 20% of the GDSII file size can be expected.

A new version of the load memory map, v1.03, is needed for this version.
Older versions of load memory maps will not be used and will be recreated with a new version.

Some memory usage improvement data:
42GB GDS 20GB to 7.3GB
32GB GDS 9GB to 3.6GB
15GB GDS 7.4GB to 2.7GB
2.5GB OAS 4.8GB to 3.1GB

Detail Notes:
- Default quad tree now stores 256 per quad instead of 32.
- Uses 5 bytes per file position. Still uses 8 per pointer when loaded into memory.

The new version of Nettrace Server v2.63.0 [nettrace.qis/nettrace.qis64] supports identifying driver points.

The new version of Nettrace supports OASIS files.
All communication between your client and the Nettrace server remains the same.

Each nettrace server instance creates its own temporary working directory 'ntrc_tmp.{processID}'. All temporary files generated during nettracing can be found here.

In order to generate the nettrace detailed log file 'nettrace.log' and the generated nets as GDSII output 'nettrace.gds' specify the -log command line option when invoking the nettrace server.
In order to generate a log of the socket communication, specify the -netlog option when invoking the nettrace server.

To ensure independence amongst the multiple server instances, each nettrace-qis server pair uses its own shared memory.
This shared memory is allocated when nettracing begins . In order to make sure that this shared memory is de-allocated correctly, use the SIGINT signal to kill the QIS server. ( kill -SIGINT {QISprocessID} )

Previous versions might stop in the middle of tracing, stop responding to further commands, or stop accepting a connection from a client program. It is not crashing nor is it in a busy loop. This has been fixed.

Older versions of NetTrace would merge the polygons of the resulting net and output to a GDSII file after the net has been sent to the client program. This process could take minutes for a larger net of hundreds of thousands of polygons and it would seem like NetTrace has stopped responding on the client program side.
This merging process is not necessary and has been taken out if -log is not specified. The tracing time is also faster without this process.

NetTrace v2.60.1 has a new problem that it would stop when tracing for the second time. It stops responding afterwards. This has been fixed.

NetTrace had problems handling GDSII files with non 0.001 grid, and files with high vertex count (over 4 billion). Both issues have been fixed.

Sending a Ntrc_Stop command to NetTrace could take NetTrace couple minutes to response for bigger file or large number of polygons. This has been improved to seconds. Though, potentially, it might still take a while to response for larger file depending on what computation is taking place at the time of a stop.

Previous versions might not generate correct net polygons if the grid of the file is not 0.001. It might interprete the test point incorrectly so the resulting net is totally wrong; or it might use the correct test point but the resulting net is scaled up or down in a ratio of the actual grid vs 0.001.

File with high vertex count would cause an overflow in the estimation calculation when NetTrace tries to partition the work flow. This would cause the algorithm to break and NetTrace might stop or crash.

There are two modes when opening memory maps directly.
If Set_Load_Memory is on, entities' data are loaded into memory when memory maps are opened directly. If Set_Load_Memory is off, entities' data are not loaded into memory when memory maps are opened directly. Default Set_Load_Memory is off.

For Set_Load_Memory on, QIS uses more memory and will be faster (if RAM is sufficient).
For Set_Load_Memory off, QIS uses less memory and will be slightly slower.

Do not use Reload_GDSII to reload memory maps because of different Set_Load_Memory setting. Reload_GDSII does not do anything if memory maps are directly opened. Simply change the Set_Load_Memory setting then directly open the memory maps again using Open_GDSII.

Previous version of QIS might copy a remembered home view on top of the existing picture even if SetDrawWindowID is on when doing a ZoomHome. This has been fixed.

NetTrace now works if the file opened in QIS is GDSII memory maps (instead of the original GDSII file).
If GDSII memory maps are directly opened in the corresponding QIS, send Ntrc_Set_Input_File with the scan memory map file name instead of the original GDSII file name. e.g.

Ntrc_Set_Input_File
/tmp/demo1.gds.scan.b64

Open_GDSII can be used to open the scan and load memory maps directly
without the original GDSII file.  The load memory map has to be created
with Set_Load_Memory set to On which would store the GDSII entity data
in the load memory map.

Specify the scan memory map and load memory map as the arguments to the
Open_GDSII command, separated by comma, double quoted if necessary.
e.g.

Open_GDSII
"/tmp/demo1.gds.scan.b64","/tmp/demo1.gds.dbload.b64"

Under this direct open mode, if either the scan or the load memory maps
fails to open, QIS sends out QIS_Error and it does not revert back to
open the original GDSII file (obviously, since it doesn't know about
the original GDSII file).  (This behavior is different from the normal
memory maps usage where QIS sends out QIS_Warning when memory maps fail
and continue on to open the original GDSII file.)

Other behaviors are the same as opening a GDSII file using the Open_GDSII
command.

The scan and load memory maps file names can be changed to anything.
But it would be good to identify them as scan, dbload, little or big
endian byte ordering and 64 or 32 bit.

When memory maps are opened directly, a GDSII file or data cannot be
created.  So the commands Save_GDSII, Save_GDSII_Structure, Get_GDSII
and Get_GDSII_Tcp don't work.

Edit commands still work, but the result cannot be saved to a GDSII file.

A new memory maps would not be created even if Set_Create_Memory_Maps
is set to On.

Directly opened memory maps do not need to be reload.  The command
Reload_GDSII does not do anything, it returns Reload_GDSII\n immediately
denoting that the reload is done.

1. "Memory map 'demo1.gds.load.b64' is not used (different load to
   memory setting)."


  This occurs when the Set_Load_Memory setting is different than the
  setting when the load memory map was created.


2. "Memory map 'demo1.gds.load.b64' is not used (cannot directly open
   memory map without data entities, memory map was not created with
   load to memory on)."


  This occurs when the load memory map specified to be opened directly
  (together with a scan memory map) was not created using Set_Load_Memory
  On.


3. "Failed to use memory map 'demo1.gds.scan.b64'.  Version not
   supported or file is not a memory map."


  This occurs when the scan memory map has a older version that QIS
  supports or the file is not a valid memory map (not a QIS format
  memory map file or a memory map file from a different platform.)


Cross platform between Linux and Unix are supported as long as the memory
map files are of the same 32/64 bit and big/little endian with the
exception that Windows QIS memory map files cannot be used for the
Unix/Linux version of QIS and vice versa.
e.g. Solaris AMD64 files can be used for Linux AMD64
    (both are 64 bit and little endian).

Memory maps file names had .b64 as the extension which is wrong. It is now changed to the correct .l64 which stands for little endian 64 bit. It is cross platform compatible with other 64 bit X86 platforms like Linux running on 64 bit processor.

QIS sends out this error message if memory maps are opened directly and Save_GDSII or Save_GDSII_Structure are sent to QIS:
QIS_Error
Cannot save to GDSII file from memory maps

QIS sends out this error message if memory maps are opened directly and Get_GDSII or Get_GDSII_Tcp are sent to QIS:
QIS_Error
Cannot extract GDSII data from memory maps
Get_GDSII
/tmp/output.gds

Directly opened memory maps do not need to be reload. The command Reload_GDSII does not do anything, it returns Reload_GDSII\n immediately denoting that the reload is done.

Use this command to send QIS a Drawable (drawing area) and QIS would
draw directly to this drawing area when a Redraw command is sent.

If this direct draw is turned on, QIS would send out Image_Ready 0 when
it finishes the drawing, it would not send out an image regardless of
what the Set_Image_Format is.  In addition, Get_Image would do nothing,
it does not return anything.

Send -1 as the argument to turn this direct draw off.  QIS would switch
back to send out an image after drawing is finished and Get_Image during
drawing could be used to get an image.

If this mode is turned on, the drawing area is not cleared using the
background color before drawing starts.  QIS draws on top of whatever
is in the drawing area prior to a Redraw command.  This behavior has
an effect of overlaying QIS data on top of an existing picture.

The client program can clear the drawing area using the background
color first before issuing a Redraw command if that is the desired effect.

Home view is not remembered/cached under this mode so the command
Zoom_Home would not be almost instant.  Home view is now also a redraw.

This Drawable/Pixmap handle should be created using the default depth
of the default screen of the same display as QIS.

The Unix and Linux versions of QIS can now generate a Windows .bmp
bitmap format image (in addition to Gif and Xpm).

Use the command Set_Image_Format and send Bitmap8U as the argument and
subsequent Get_Image and Image_Ready images will be in .bmp format.
This argument is an invalid argument for the Windows version of QIS.

The format is 8 bit uncompressed RGB.  If the image bytes are saved to a
file, it would be a valid Windows .bmp format file.

The image bytes can also be used directly to set the pixels of a Windows
GDI bitmap using the Windows GDI function SetDIBits.  The bytes are
formed by these components:

BITMAPFILEHEADER
BITMAPINFOHEADER
RGBQUAD color array (array size is specified in biClrUsed of BITMAPINFOHEADER)
bitmap bits

BITMAPINFOHEADER, RGBQUAD array and bitmap bits are sufficient to a
SetDIBits function call, BITMAPFILEHEADER is not necessary.
BITMAPFILEHEADER is only needed to generate a .bmp file.

For 32 bit QIS, even if Set_Load_Memory is Off, it would still check if
enough memory is available as if Set_Load_Memory is On thus preventing
QIS to open the file since it doesn't actually need that much memory:


QIS_Error
4.7GB of memory is needed to view demo1.gds.
Maximum memory is 4GB.



For both 64 and 32 bit QIS, when Set_Load_Memory is Off and there is
a memory error, it would generate this error message:


QIS_Error
1.2GB of memory is needed to view demo1.gds.
The system does not have enough memory.


When Set_Load_Memory is Off, the reported memory requirement is wrong,
it does not need that much memory.  This has been fixed to:


QIS_Error
Memory error occurred when starting to load demo1.gds.
The system does not have enough memory.

This version passes all the OASIS test files from OASIS Tooling in both reading and writing.
This represent almost a year work after our initial OASIS support.
QIS has not "passed" the OASIS Tooling "Level-3 Writer Optimality" benchmark, namely, QIS is not doing any pattern recognition, it does not generate any OASIS output "smarter" than the input.

Previous versions might not check for various OASIS errors and might generate incorrect OASIS output files. These have been fixed in this major OASIS release.

Previous versions would show incorrect structure extents or data would be missing if the structure has array references with over 32767 rows or columns. This limit has been raised to 65535.

QIS might not return when generating a Tiff image for Get_Hires_Image or Get_Hires_Image_Tcp. It is not in a busy loop, it has 0% CPU usage, but it does not return back to the client program and it stops responding to further commands. This might happen depending on the nature of the data vertices.

The grid in a GDSII file might be interpreted as 0.000999999999992 instead of 0.001 and thus data would be shown with 11 decimal points which caused the GIF to be corrupted. This has been fixed.

New Environment Variable - ARTWORK_LINUX_PRECISION
Argument - 64 or empty value
Set this environment variable to 64 to use 64 bit floating point value precision instead of the default 80 bit on Linux. If this env var is not set or the value is not 64, then the default 80 bit precision is used. Default is 80 bit.

New Environment Variable - QIS_SET_OASIS_CHECKSUM
Argument - On or Off.
Set this environment variable to Off to turn off OASIS checksum checking before launching QIS. If this is off, the checksum value will not be checked against the file's checksum for potential file corruption. Default is On.

This version supports FLEXlm licensing version 11.

Certain odd polygons (e.g. non convex, self touching) might be dropped and thus produced an incorrect Tiff output. This has been fixed.

Argument - Number of seconds
If this time out value is specified, NetTrace will wait for the number of seconds and exit itself after the client is disconnected from NetTrace. During the waiting period, if a client is connected to NetTrace again, NetTrace will not exit when the time expires.
To cancel this time out while a client is connected, send 0 as the time out value.
Default is no time out.

-log[:log files directory]
Specify this command line option to instruct NetTrace to generate log files for debugging purpose. The files are:
ntclient_0.log - logs communication between NetTrace and a client program qisclient_0.log - logs communication between NetTrace and QIS nettrace.log - logs net tracing computation nettrace.gds - a GDSII file which contains the polygons of the net.
If -log is specified, these log files will be generated in the startup directory of NetTrace.
If -log:/tmp is specified, these log files will be generated in the specified directory.
Default is not to generate any of these log files.

Previous versions of NetTrace might not have the startup status available on stdout after it has started. A client program might be waiting for this status string through a pipe and never gets a response. This has been fixed.

Previous versions of NetTrace would always return 1.80 as the version number. This has been fixed.

Client->NetTrace Ntrc_Get_Version\n
NetTrace->Client Ntrc_Get_Version\n
2.42\n

For GDSII, if there are multiply defined structure(s), older QIS would use the last structure definition. This has been changed to use the first structure definition. Subsequent definitions of the same structure are now ignored.
Previous versions of QIS might crash when there are structure redefinitions depending on the number of structures and the number of redefinitions. This has been fixed to not crash.
When there are structure redefinitions, QIS will send out this warning after loading:
QIS_Warning\n Multiply-defined structures (structure redefintions are ignored)\n Struct_1,Struct_8,Struct_16\n

In general, for correct GDSII files, no changes are made regarding
memory maps.  Old memory maps can be opened by this newer QIS.


Previously generated memory maps are not used by this new QIS if the
GDSII file has structure redefinitions.  QIS will send out this warning:


QIS_Warning\n
Memory map 'demo.gds.scan.b64' is not used (structure redefinitions
are now ignored).\n


QIS will then generate new memory maps.


New memory maps generated by this new QIS can be used by older QIS.

Previous versions would send out a duplicate list of undefined
structures if the load memory map exists but not used due to various
reasons.  e.g.


QIS_Warning\n
Undefined Structures\n
Struct_1,Struct_8,Struct_16\n
,Struct_1,Struct_8,Struct_16\n

This has been fixed.

Previous versions of QIS for Windows would not use a scan memory map if the GDSII file is larger than 2GB. This has been fixed.

The GDSII extraction commands, Get_GDSII and Get_GDSII_Tcp, now also work when an OASIS file is opened.
Note that the GDSII output is flat (no hierarchy, no array/repetition) and all data are converted to boundaries.
Note that if an OASIS polygon has more than 8191 vertices, the GDSII output will be truncated at the 8191 vertex and the polygon is closed.

Added control to add a round polygon by specifying the center, radius and arc resolution in degrees. A polygon with many vertices that looks like a circle will be added. Use the Add_Vector to add an "R" vector.

Add_Vector
R,StructureName,Layer:Datatype,CenterX CenterY,Radius,ArcResolutionDegree
Radius has to be greater than 0. Arc Resolution is in degree and should be greater than 0 and less than or equal to 90. This determine how smooth the circle should look. A vertex is generated at every specified degree.
When doing get vector, R vector is output as a normal boundary as "B" vector.

This version of QIS passes all the incorrect test cases of Level-1, all test cases of Level-2 and all test cases of Level-5 Corner Cases
. Together with the improvements made to v2.40, QIS passes all Level-1, 2 and 5 OASIS reading tests with 3 exceptions:
1. Since QIS ignores all OASIS property records, incorrect property records are not reported as fatal error.
2. text_same_name_textstring.oas (this will be fixed in a future release)
3. path_bbox_BBox.oas (this will be fixed in a future release)
Also note that self intersecting polygons are not considered as error by QIS.
(Level-3 is for writing OASIS, and Level-4 is for reading OASIS Variable Shaped Beam mask pattern generators)

Check for CRC/CheckSum
Check for pointlist type 0 and 1 coincidental points
Check for pointlist type 0 and 1 colinear edges
Check for pointlist type 2 non-manhattan closing edge
Check for pointlist type 3 non-octangular closing edge
Check if pointlist type is out of range
Check if ASCII strings contain illegal character
Check if name strings are zero length or contain illegal character
Check if end record padding string contains non-NUL character
Check if table offsets are invalid file positions
Check if end or cell record is inside CBLOCK
Check if XYABSOLUTE or XYRELATIVE record is outside of a cell definition
Check if validation scheme is outside the range of 0 to 2
Check if table offset flags are not 0 or 1
Check if version string is not exactly "1.0"
Check if unit is negative, zero or NAN
Check if layername intervals are out of range of 0 to 4
Check if the most significant bit of text info byte is not 0
Check if the 2 most significant bits of polygon info byte are not 0
Check if the 2 most significant bits of circle info byte are not 0
Check if cell name is used to define or reference a cell under strict mode

Maximum number of vertices supported is raised from 8191 (GDSII spec max) to 250,000.
If an OASIS boundary or path has more than 250,000 vertices, it will be truncated at the 250,000th vertex. Truncated boundary will be closed.
Maximum number of entities for each repetition x or y dimension is increased from 2G to 4G
Maximum total number of entities for each repetition is increased from 32 bit max unsigned int (4G) to 64 bit max unsigned int
Maximum total number of boundaries, paths, texts, references per cell is increased from 32 bit to 64 bit

If a file has cell names in strict mode, all cell definitions and references should be using reference numbers. If that is not the case, an error would occur during scanning but the error would say it is a memory error. This has been changed to a better error message: "Only reference-number access is allowed for cell strict mode."

Tiff extraction has been speed up by 2-3 times especially when many windows are extracted sequentially.

A bug was introduced to QIS v2.35 to v2.40 where data might snap to a different grid or disappear when zoom in tight. This would only occur when data are transformed to a grid of higher resolution and the resolution is raised by Set_Resolution or Set_DBU. When zooming in tight, it would still use the old resolution and caused the snapping/disappearing.

The windows version of QIS might print out an invalid number if the number of data is over 4 billion (max 32 bit). (number of boundaries, paths, texts, srefs, arefs, vertices) This has been fixed.

This release reflects a bug fix associated with GDSII grid that did not conform to 1000.

If Set_Outline_Filter is set to On, the outline of a polygon is not drawn. See command description in documentation page for more information.

This release reflects a bug fix associated with GDSII grid that did not conform to 1000.

Drawings of text can now be scaled using this command. The text font number for GDSII ranges from 0 to 3. Use font number 0 for OASIS text.

The length and/or width of a Tiff output could be off by one pixel if the correct width is less than 25 pixels. Data touching along the border could also be off by one pixel. This has been fixed.

In previous versions, the above file I/O operations might be very slow on AMD Opteron machines if the file is across a network. This has been fixed.
Note that the OASIS CBLOCK fix affects both file loading and drawing/vector data processing.

QIS v2.37 would crash if -nodisplay is specified and a Tiff is extracted or getting vectors for paths as boundaries. This has been fixed.

Different scales can be specified for X and Y. This might be useful for drawing and Tiff extraction.
GDSII and OASIS output with hierarchy will not have the correct scale and rotation in the references because they don't support different XY scales. (Save_GDSII, Save_GDSII_Structure, Save_OASIS and Save_OASIS_Structure).
GDSII and OASIS output path width will not look the same as drawing because the width might look different along the x and y axis but there is only one width in the GDSII or OASIS output.

Previous versions would output a Tiff output with the image width in pixels rounded up to a modulo of 8. This has been changed to the exact width in pixels. The Tiff image itself has been correct and has not been changed, just the image width in the header of the Tiff file has been changed to have the exact width.

All paths except paths with round ends are drawn using a new algorithm. The picture might look different from previous versions.
When getting vectors of paths as boundaries, the vectors coordinates could be different because the boundar(ies) forming the paths might be different in this new version.
In general, all paths (except round ended paths) are now broken into pieces of boundaries and these pieces are merged back into a boundary.

If a path has a segment shorter than the width of the path, the path could be drawn incorrectly with a diagonal cut line. This has been fixed.

If a boundary or path forms a donut shape with a hole in the middle, extracting an area inside the hole would generate a polygon which is the size of the extraction window. The resulting Tiff output would be all black (or white).
If the extraction area crosses the donut shape boundary or path, it would be dropped.

Various combinations of cell definition, placement or CELLNAME records in an OASIS file might mean a cell is defined more than once. This version now checks for this OASIS file error.

(a cell placing a copy of itself within itself).
This version now checks for this cell recursive placement error.

Previous versions might incorrectly generate an error when opening an OASIS file with CTrapezoids. The error might be one of these:
CTrapezoid type 12-15 cannot have height less than twice the width.
CTrapezoid type 4-7 cannot have width less than twice the height.

The checking rules for these CTrapezoids have been corrected and the error messages have been changed to these:
CTrapezoid type 0-3 and 6-7 cannot have width less than height.
CTrapezoid type 4-5 cannot have width less than twice the height.
CTrapezoid type 8-11 and 14-15 cannot have height less than width.
CTrapezoid type 12-13 cannot have height less than twice the width.

QIS now outputs QIS Startup Status(0) to stderr on the Windows version when it is started successfully together with the port number where it is started. e.g.
QIS Startup Status(0)
Port Number(12345)

A client program can launch QIS and capture the stderr output through pipe to monitor whether QIS has started successfully.
When QIS failed to start, the executable still returns the error code as before.

Scanning speed has been improved an average of 12% and loading speed an average of 6%.

Error messaging for problems parsing OASIS files has been greatly enhanced. First, the error messages are much more precise that before. Second, the error message includes a few bytes preceding the error which should enable the programmers to better determine what triggered the error.

Example

In the example below, the OASIS reader encountered a fatal error because a CTrapezoid did not meet the rule that the width must be less than twice the height.

CTrapezoid type 4-7 cannot have width less than twice the height.
Record starts at file offset 53732.
Record bytes are: 1A F8 06 9E 0F 9A 08.

While the actual file offset is of no use if you don't have the file, the bytes shown actually include the coordinate data for the trapezoid.

We have increased the range for both layer and datatypes (this applies to both GDSII/OASIS)

• layer and datatype now range from 0 to 65535.
  
• max number of different layer numbers is 2048.
  
• max number of different datatype numbers is 256.
  
• Together, the maximum number of layer:datatype combinations supported is 65,536 (not 524,288).
  

Client programs might need to be changed to support layer and datatype numbers in the range of 0 to 65,535.

Added "all layers off" control to turn all layers off for these 2 commands. Send the argument All-NULL to turn off all layers. This command is useful for instructing QIS to load only a limited set of layers. For example, if you have a 10GB GDSII file with data on 20 different layers but know that you only want to look at layer 38 and 39, QIS will load faster, display faster and use less memory if you do the following prior to issuing the open_gds command:

Set_Input_Layer_Map
All-NULL,38-38,39-39

In general, there are 10 different types of argument to these 2 commands:

1. All-NULL (all layers off)
   
2. All-10 (all layers map to layer 10, datatypes remain the same as original)
   
3. All-10:20 (all layers map to layer 10 datatype 20)
   
4. 10-NULL (layer 10 all datatypes off)
   
5. 10-30 (layer 10 all datatypes map to layer 30, datatypes remain the same as original)
   
6. 10-30:40 (layer 10 all datatypes map to layer 30 datatype 40)
   
7. 10:20-NULL (layer 10 datatype 20 off)
   
8. 10:20-30 (layer 10 datatype 20 map to layer 30, datatype remain the same as original)
   
9. 10:20-30:40 (layer 10 datatype 20 map to layer 30 datatype 40)
   
10. Off (turn off layer mapping)
    

As a result of the new layer and datatype numbers range, this version of QIS creates and uses a new version of scan memory map, v1.03, and a new version of load memory map, v1.02. Older scan and load memory map will not be used and a new version will be created.

Previous versions would draw large extents data at the wrong coordinates if resolution is changed by the Set_Resolution command and zooming is very tight into the data. This has been fixed.

Previous QIS versions (Windows) would not be able to save over an existing file; an error messsage: "Cannot save to the same GDSII file" was generated. This has been fixed. Note: The output file still cannot be the same as the input file.

Previous version crashed when Save_GDSII or Get_GDSII is used to save to a GDSII file. This bug only happened on IBM AIX. This has been fixed.

QIS/Nettrace has a few new commands. You can go to the QIS Documentation page for more detailed information.

1. Ntrc_Set_Stackup_File - You can now specify the stackup file on the machine, where NTS(Nettrace server) is running.
2. Ntrc_Set_Show_Details - You can now turn on or off the printing at the NTS console. You can turn it on only for debugging/ trace purposes.
3. Ntrc_Exit - You can control the exit of NTS from the remote client. You can ask NTS to exit by sending this command.

You can now use the -h to get the help screen.

nettrace.qis[64] -h

Nettrace Server(NTS) v2.341 (18 November, 2005 - 32MT)
Copyright © 2005 Artwork Conversion Software, Inc.  (831)426-6163
info@artwork.com,  http://www.artwork.com

usage is

nettrace.qis[64] [options]

options


     -ntip:ipaddress    ipaddress is the ip address where NTS should run.
                        You can also set this parameter using env. variable NTIP
     -ntport:portno     portno is the port number where NTS should run.
                        You can also set this parameter using env. variable NTPORT
     -qisip:ipaddress   ipaddress is the ip address where QIS is running.
                        You can also set this parameter using env. variable QISIP
     -qisport:portno    portno is the port number where QIS is running
                        You can also set this parameter using env. variable QISPORT

SUSE release includes both qis64 (64 bit) and qis (32 bit) executables.

Use this command to get the directory and file names available in the file system of the QIS running machine. Clients running remotely and connecting to this QIS can now instruct QIS to open a file on the QIS' file system.

Previous versions of QIS might crash when multiple clients are disconnecting from it around the same time. This has been fixed.

Previous versions of QIS might crash when multiple clients are disconnecting from it around the same time. This has been fixed.

File browser server (fbserver) is not being shipped as part of this package. File browser capability has been added to QIS v2.34. The 32-bit and 64-bit QIS binaries shipped with this product are v2.34.

QIS/Nettrace/ File Browser server package is updated and contains QIS v2.33, optimized Nettrace server and updated file browser.

Each window request made to QIS caused Nettrace to be delayed by atleast a second in the previous version. This has been fixed.

In the previous version, for each net trace request, server use to delay for 4-5 seconds before doing the real work. This delay has been reduced to less than a second.

This option can be added to the preferences argument of Ntrc_Set_Preferences as
-optcellsize:number
where, number is the vertices per window.
This option tells nettrace server that these many vertices per window will be favourable for net-trace calculation. We found that the default optimal value for this option is 50,000, based on our in-house benchmarking. However, a number between 50000 to 10000 can be suitable depending upon the density of data.

This option can be added to the preferences argument of Ntrc_Set_Preferences as
-optcellsize:number
where, number is the vertices per window.
This option tells nettrace server that these many vertices per window will be favourable for net-trace calculation. We found that the default optimal value for this option is 50,000, based on our in-house benchmarking. However, a number between 50000 to 10000 can be suitable depending upon the density of data.

This option can be added to the preferences argument of Ntrc_Set_Preferences as
-stackupstart:depth
where,
depth is the initial stack-up depth server should use. If it is 0, then nettrace server calculates it automatically based on data.
With this option turned on user gets a better appearance of the net since it traces to the specified depth in the first pass. However, the down side of this option is if net goes all the way down in the the stack-up then it will need to re-visit all the cells in its second pass.

Nettrace server makes two attempts to adjust the intial window size if it is not the optimal size based on the number of vertices per window specified. This was not the case in the previous version.

This version of nettrace server uses the the qisnetlib64.mt.so/ qisnetlib.mt.so shared object. This is the multithreaded version of the library, which is freely available to the customers who need to build their own Qis Client.

For UNIX and Linux only we added a new raster format called XPM. After setting the image format to XPM, images for Image_Ready and Get_Image commands will be in XPM format.

Previous versions of QIS might crash if it failed to use the scan memory map or if a Stop command was sent to QIS while it was reading the scan memory map. This has been fixed.

Draw, scan and load speeds have been improved by using a file I/O buffer size of around 4K bytes. Draw times show a speed up of 1X to 18X with an average of 3X depending on zoom in level and display filter sizes. Scan and load times speed up depends on OS and network settings and could be minimal.
The environment variable QIS_GDSFIO_BUF_SIZE does not do anything in the version. It might be reactivated to control the file I/O buffer size in future versions.

As a result of the speed improvements, this version of QIS creates and uses a new version of scan memory map, v1.02. Older scan memory map will not be used and a new v1.02 scan memory map will be created.
No changes to load memory map.
The first 5 bytes of the scan memory map binary file now also show the version in ascii text. A binary dump program can be used to show the first 5 bytes in order to get the version of a scan or load memory map.

This new release is for the standard QIS and for the special Synopsys version. All the updates from version 2.16 are now implemented in the standard version of QIS.

This version of QIS supports OASIS. OASIS and GDSII are activated by separate licenses.
Refer to documentation for QIS v2.20 to v2.27 for new OASIS commands.

This command returns the license status or error messages for each of the features QIS supports.

This version of QIS supports more than 1 client to connect to it. The first connected client has the highest priority meaning that QIS would only process commands from the second client if the first client is quiet.
The states of QIS might be changed by another client, in which case, the first client might not know the current states of QIS. There is currently no commands to get the states of QIS nor does QIS broadcast it's states to all clients.

Previous versions would draw the fill patterns for all layers first and then the outlines for all layers. This has been changed to drawing both the fill patterns and outlines for each layer within a structure before moving on to the next layer.
The result could be a 2X speed up for drawing in fill mode. However, the outlines could now be covered by the fill patterns of other layers.

QIS v2.26 and v2.27 would not go deeper than 1 structure reference hierarchy level when Set_Load_Memory is on. It happen for both image drawing mode and vector mode. This has been fixed.

Fill pattern with index greater than 255 would be ignored since v2.20. This caused the effect that setting a layer to outline only using the empty fill pattern (index 999) to be not working, the layer remained filled. This has been fixed.

Previous versions of QIS might crash with a signal 10 if it uses Artwork host ID licensing and it is busy opening a file. This happens when the license is refreshed while at the same time it is allocating memory during a busy file open. This has been fixed.

Previous versions of QIS would generate a license check out error on the FlexLM license server log file for product ACS6555: 16:30:38 (artwork) UNSUPPORTED: "ACS6555" (PORT_AT_HOST_PLUS ) user@server (License server does not support this feature (-18,327)) ACS6555 has been obsoleted and taken out. This error should not happen from now on.

The socket libraries receive algorithm has been changed from a complex handling to simple and efficient handling. This could result in a communication speed up and less memory usage when many commands are sent to QIS at the same time.

The header printed out to stdout when -h is passed to QIS as a command line argument now shows (NTI 2004.12) or (NTI 2005.09).

Previous versions might hang when extracting a polygon with self touching vertices. This has been fixed.

QIS now uses -15 as the windowBits parameter for compressing and decompressing OASIS CBLOCKs. This fixes the problem that QIS failed to open OASIS files generated by Synopsys' programs.

Various changes have been made to creating and using memory maps.
However, the versions of both the scan and load memory maps remain the
same as previous QIS releases, they are compatible, no changes are
necessary to the client program.

1. If a memory map does not exist and QIS is set to create memory map,
   it will create the memory map and keep in read only mode.
   QIS will overwrite this read only memory map if it has the permission
   to change the read/write permission mode of the file.

   If a memory map already exists and QIS is set to create memory map,
   QIS remembers the permission modes of the file and then tries to
   change the file to writable.  If the file can be changed to writable,
   then QIS will overwrite the memory map and keep the new memory map
   file in the remembered permission modes (instead of read only).

2. Errors when creating memory maps are now reported with more details.
   System error would be reported in the warning message if available.
   e.g. QIS_Warning
        Failed to create memory map 'demo1.gds.scan.b64'.  Permission denied.
   Detail warning messages are listed below.

3. If QIS fails to create a memory map, and the file is partially created,
   it is removed.

4. When using a memory map, the modification time stamp is checked against
   the GDSII file.  If the memory map is older than the GDSII file, it
   will not be used.  It will be overwritten if create meory map is turned
   on.

5. When using a memory map and the version of the memory map is not
   compatible with the QIS version, a specific warning message is sent.
   e.g. QIS_Warning
        Failed to use memory map 'demo1.gds.load.b64'.  Version not supported.

This version has detail OASIS open error messages which might help to better understand specific files we are having problem with.

By default, QIS generates temporary files in the directory where QIS is started. Use this command to set a different working directory.

OASIS open speed has been improved by 1% to 40% with an average of 15% speed up. Opening speed is now 1% faster than the corresponding GDSII file on the average (with no compression and compaction on the OASIS file).
OASIS memory usage has been lowered by 35% to 75%, averaging 45% comparing to v2.25. It now has an average of 86% more memory usage comparing to the corresponding GDSII file, down from an average of 300% more.

In previous versions, Get_Structure_Children and Get_Structure_Children_Num
would show references to undefined cells as references to the first
defined cell, and they would be listed multiple times.  This has been
fixed.  e.g.


Wrong behavior before:


TOP,Cell_B,TOP,Cell_C


Correct behavior now:


Undefined_Cell,Cell_B,Cell_C
================================================================
OASIS Output File Should Not Be The Same As The OASIS Input File


If the OASIS output file is the same as the input file, these errors
would be generated:


1. For Save_OASIS and Save_OASIS_Structure


   QIS_Error\n
   Cannot save to the same OASIS file\n


2. For Get_OASIS


   QIS_Error\n
   Cannot save to the same OASIS file\n
   Get_OASIS\n
   /tmp/original.oas\n
=======================================================================
GDSII Output File Can Be The Same As The GDSII Input File Except
Extraction Under Non-Edit Mode


For GDSII, only if Set_Load_Memory is Off and Get_GDSII is sent to
output to the same GDSII file then a new error would happen.  Other
combinations are OK for GDSII to output to the same input GDSII file.


Client->QIS
Get_GDSII\n
/tmp/original.gds\n


Client<-QIS
QIS_Error\n
Cannot save to the same GDSII file\n
Get_GDSII\n
/tmp/original.gds\n

This version opens OASIS files on the average 30% faster.

Stopping an OASIS file open is more responsive in this version. Files with CBLOCKs were not stoppable during a big CBLOCK uncompression, this has also been fixed.

Adding an existing OASIS cell via Add_Structure command did not generate an error. This has been fixed to output this error:

QIS_Error\n
Structure 'TOP' already exists\n
Add_Structure\n
TOP\n

Previous versions would only output polygons as type 4. This version would output all polygon types depending on the polygon.

Previous versions would not send out vector data with the data handle even if the Set_Vector_Handle command is set to on. This would happen if Set_Vector_Handle is sent to QIS before an Open_GDSII, Reload_GDSII or New_GDSII. This has been fixed.

Previous versions would not draw the outline and label for the viewing OASIS top cell if they are turned on thru Set_Structure_Outline and Set_Structure_Labels. This has been fixed.

This revision is an OASIS editing alpha release.

Please review each command in the documentation pages. New_OASIS, Reload_OASIS, Save_OASIS, Set_OASIS_Compression, Save_OASIS_Structure, Get_OASIS, Get_OASIS_Tcp

These 2 commands only work if a GDSII file is opened or a new GDSII is created through New_GDSII. They don't work for OASIS and will return back Get_GDSII and Get_GDSII_Tcp respectively right the way.

When a file is being opened, some commands sent to QIS are ignored. The warning message for such a case has been changed from:
GDSII open in progress, command ignored.
to:
File open in progress, command ignored.

If more than 64 commands were sent to QIS at once, only the first 64 commands were processed, the rest were skipped. This has been fixed.

Previous versions might generate wrong structure extents or hang if many Add_Vector commands are sent to QIS. This has been fixed.

Previous versions of QIS would crash if Set_Load_Memory is turned on to load the file into memory for editing and the memory needed to load is over 8GB. It would crash when actual GDSII data are drawn (when data are not filtered out) and they happen to be in memory space which is over 8GB. This has been fixed.

This revision was made to the last non-OASIS release and is intended for production release to Synopsys for their March service patch of ICWB.

Use this command to control whether QIS returns a vector handle after receiving from the client an Add_Vector command.

Off is a new argument to this command. When set to OFF structure/cell references and array references vectors (S and A vectors) will not be returned by QIS for Get_Vector, Get_GDS_Vector, Get_Display_Vector, Get_Vertex_Info and Get_Window_Info commands. this option was added in response to a request by Synopsys when making batch edits to a database.

If the keyword All is used instead of a vector handle, all paths and boundaries, old or newly added, in the current structure will be deleted. To undelete them, use Undelete_Vector. Requested by Synsopsys.

If the keyword All is passed instead of a vector handle, all paths and boundaries, old or "newly added and then deleted", in the structure will be undeleted.

This version supports paths with end type 4 (variable extension). These paths will be drawn correctly - however they are not output as type 4 but rather as type 0 (flush) and the endpoint coordinates are compensated according to the custom extension value.

when a new layer is added to the database it is now ON by default.

the Set_Magic command (which controls AREF intpretation) is obsolete. QIS now correctly interprets AREF's without the need for the user to set this parameter.

The new AREF interpretation also fixes incorrect calculation of the array bounding box.

Previous versions would truncate a grid value of 0.025 to have only 2 decimal points precision; all xy coords and measured distance were returned with incorrect values. This has been fixed so that the grid precision is no longer truncated.

All commands should work exactly the same for both GDSII and OASIS except the following: editing, saving and memory maps related commands:

API Call               OASIS Behavior

Add_Vector             Returns N-4  "file not loaded into memory"
Delete_Vector          Does nothing
Undelete_Vector        Does nothing
Add_Structure          Does nothing
Add_Layer              Does nothing


Set_DBU                Does nothing
Set_Resolution         Does nothing

Save_GDSII             Returns Save_GDSII
Save_GDSII_Structure   Returns Save_GDSII_Structure
Set_Output_Layer_Map   Settings are not used because no 
                       GDSII file can be saved.


Set_Memory_Maps_Dir      Ignored for OASIS
Set_Create_Memory_Maps   Ignored for OASIS
Set_Use_Memory_Maps      Ignored for OASIS

Get_DBU

If an OASIS file is loaded, this command returns only a single value - the grid. This is because for OASIS, the units are hardwired to UM.

Set_Box_Boundary


This API command is ignored by QIS for OASIS files (since they do not have the BOX entity)

Set_Magic


this command (which modifies QIS's interpretation of GDSII array references) is ignored when reading an OASIS file.

The API commands: Get_GDSII, Get_GDSII_Tcp, Get_Hires_Image and Get_Hires_Image_Tcp are now supported for OASIS files.

All vector commands are now working for OASIS. API syntax is identical for GDSII and OASIS.

The API call, Get_Data_Number_Per_Layer, calculates the total number of polygons/boundaries using the OASIS repetion values: e.g. 1 boundary with a repetition of 5 will be reported as 5. Boxes are alway reported as 0 for OASIS.

OASIS repetitions do not correspond directly to the GDSII AREF. Hence there are some differences in reporting quantities when this API command is used for an open OASIS file:

Array mode 0,1,2 only works for OASIS cell reference repetitions with N x M rows and columns. These cell reference repetitions are reported as 'A' (aref) vectors.

Cell references with random repetitions are treated as separate cell references, array mode has no effect for random repetitions. These cell references are reported as 'S' (sref) vectors.

Repetitions of elements other than cell reference are treated as separate elements. They are not reported as repetitions.

This command now works for OASIS files.

This command now works for OASIS files

All OASIS filtering quirks in v2.20 have been corrected. OASIS filtering now behaves the same as GDSII.

Version 2.20 might not draw some data when element properties were represented in the OASIS file as modal variables. This has been fixed.

QIS_Error\n
Missing Cell name\n


QIS_Error\n
Cell 'ABC' does not exist\n

Version v2.20 incorrectly interpreted coordinates when vector unit was set to DBU. This has been fixed.

Version 2.20 reported empty OASIS cells' extents as 2147483.647,2147483.647,-2147483.647,-2147483.647. This has been fixed to report 0.000,0.000,0.000,0.000.

User Unit: um
Database Unit: 1000 (per um)
Number of Cells: 7
Cell References: 8 (25)
Boundaries: 82 (87)
Paths: 14 (14)
Vertices: 448 (473)
Texts: 6 (6)
Scan Time:
  0 min 2 sec (elapsed time)
  0 min 1 sec (CPU time)
Load Time:
  0 min 3 sec (elapsed time)
  0 min 2 sec (CPU time)

In the above example the number of boundaries reported shows 82(87). 82 indicates the number of boundary records and the 87 indicates the total number of boundaries when repetitions are counted.

This is the first version with limited OASIS support. No changes to GDSII functions.

1. Only 1 OASIS or GDSII file can be opened by QIS at one time. If a GDSII file is opened and Open_OASIS is sent to QIS, QIS closes the GDSII file then open the OASIS file, and vice-versa.

2. All OASIS features are supported except: circles, properties (including cell extents) and validation signature. These 3 OASIS features are ignored by QIS. Cell extents properties will be supported in a future release.

3. A temp file, acs_oasis_dataXXX.bin, is created in the QIS startup directory when an OASIS file with CBLOCK data is opened. This file is removed when QIS exits or when the OASIS file is closed by the command Close_OASIS. The file contains the uncompressed data from the C-blocks.

The following new OASIS specific commands have been added:

Open_OASIS

Close_OASIS

Only a limited set of the QIS functions are currently available when opening an OASIS file.

API calls for getting vector data, loading file into memory, editing, saving to GDSII, GDSII extract, high res TIFF extract and memory maps for OASIS. Vector data will be supported in the next release.

Drawing of filtered areas might be incorrect if Set_Draw_Filtered_Areas is not set to Off. This will be implemented correctly in the next release.

Filtered cell references are always drawn in the SDF color even if all layers in the cell are turned off. This will be implemented correctly in the next release.

OASIS files with CBLOCK might not be drawn correctly under AMD64 Linux. QIS might crash during opening. This will be fixed in the next release.

Open/Display of OASIS file bigger than 2GB has not been tested.

Speed and memory usage performance have not been optimized.

The following API calls should not be used for OASIS files as they might cause QIS to crash:

   Set_Array_Mode
   Set_Load_Empty_Ref
   Set_DBU
   Set_Resolution
   Set_Input_Layer_Map
   Set_Output_Layer_Map


   Get_Data_Number_Per_Layer
   Get_QIS_Report
   Get_GDSII_Tcp
   Get_GDSII
   Get_Hires_Image_Tcp
   Get_Hires_Image


   Vector Data
   -----------
   Get_Window_info
   Get_Vector
   Get_Vertex_Info
   Get_GDS_Vector
   Get_Display_Vector
   Get_Structure_References
   Get_Structure_Tree


   Edit
   ----
   Save_GDSII_Structure
   Save_GDSII
   Add_Vector
   Delete_Vector
   Undelete_Vector
   Add_Structure
   Add_Layer

Previous versions of QIS did not properly interpret grid values which were not powers of 10 i.e. 0.001 is OK but 0.025 was not correctly converted resulting in all coordinate data off. This has been fixed.

Extents for empty structures are initialized as (0,0) (0,0). If entities are added to an empty structure (during editing or boolean operations) the extents calculation still used (0,0) as the lower left or upper right coordinate possibly producing an incorrect extent. This has been fixed to reflect the true extents.

This command has been implemented to account for slight differences in how programs based on MAGIC write the AREF transformation parameters. If after opening a file one sees unusual or incorrect display it may be due to the way that QIS is interpreting the AREF transformations.

The interpretation can be modified either by:

1. Using a new Command Set_Magic to On
2. Setting an Environment Variable QIS_SET_MAGIC = On

This API command should be set prior to opening a GDSII file and should not be changed once the GDSII file has been opened.

Default setting = Off (non magic).

The method in which color allocation is done has changed. If the client sets an RGB color and QIS cannot add this to the color allocation table because either: the color does not already exist in the system default color table or the color table is full, QIS will use the closest color currently available from the default color table. Previous versions issued an error message. Errors are no longer generated and this is now transparent to the client.

This new behavior affects the following API commands:

Set_Layers_Outline_Color

Set_Layers_Fill_Color Error

In earlier versions of QIS, if either command could not allocate the specified RGB color for the layer, QIS would stop on the first failed layer and the rest of the layers/colors specified in the list would not be set. However, QIS did not provide the client enough information to recover from such an error.

In this version, QIS cycles through the entire layer/color list and attempts to set all layer/colors. If the desired RGB color cannot be allocated then QIS cycles through the available RGB colors already allocated and uses the "nearest" one based on the Euclidean color cube distance.

The QIS Client issues the following command:

Set_Layers_Outline_Color\n
1-65535 12345 456,2-0 65535 0,3-7654 9876 65535,4-0 0 65535\n

Assume that an color allocation error occurs for layers 1 and 3 because the exact RGB color cannot be allocated and no other color can be allocated but QIS succeeds in allocating a table entry for colors 3 and 4. It then returns the following error message:

QIS_Error\n
Error occurred while allocating the specified color\n
Set_Layers_Outline_Color\n
1-65535 12345 456,3-7654 9876 65535\n

QIS v2.13    (10/5/2004)

This version supports GDSII file name with path of up to 1023 characters long for Solaris, 1022 for HPUX, 4095 for Linux and 259 for Windows.

Get_GDSII_Tcp, Get_GDSII, Get_Hires_Image_Tcp, Get_Hires_Image would leave behind a temporary file Results_0.txt. This file is now removed after each operation.

Added environment variable, QIS_GDSFIO_BUF_SIZE, to control the file reading buffer size. Default is 256K (262144). Specify a size in bytes which is a power of 2 (e.g. 1024, 8192, 65536, etc.)

QIS might not reply for some complex data, where in, some or more rows of pixels have less pixels in number than its compacted size. This has been fixed in this patch and will be in effect in our next official release.

Previous versions might crash if new data are added and resolution is changed using Set_Resolution. This has been fixed.

Previous versions might not scale data correctly when changing resolution if the data are newly added, then deleted and then undeleted. This has been fixed - data added and then deleted would also be scaled probably according to the resolution change.

For the following commands: Get_Structure_List, Get_Structure_Children and Get_Structure_Children_Num QIS now returns the list in 64KB blocks. This enables the client to start processing the data without waiting for the complete string (which could be many MBytes for large files) to arrive.

The internal change also speeds up QIS's response - as much as 10X.

A new command has been added:

Set_Draw_Filtered_Areas

This command controls how areas (quad) which are smaller than the display filter are rendered. A area is divided into 4 quads and two crossing areas along the vertical and horizontal centerline of the rectangular area.

   Arguments

    On    - draw all subdivisions (default)

    Off   - all areas smaller than the display filter are not 
            rendered.

    Quad  - only the 4 quad regions are to be drawn as a 
            colored area; the 2 crossing areas are not rendered.

    Cross - only the 2 crossing areas to be rendered.

QIS 2.10 is now available for the AMD64 Opteron in full 64 bit mode running under the Red Hat Enterprise 3.0 (for AMD64) operating system. The main advantage of 64 bit version is its ability to access more RAM.

The scanning and loading routines have been rewritten to better handle large GDSII files that have hundreds of thousands or even millions of structure definitions.

The internal format of the scan memory map has been updated -- maps created by previous versions of QIS are not compatible and must be rebuilt.

Should a client attempt to load an "old" memory map into this version of QIS a warning will be returned:

QIS_Warning
Failed to use memory map "abc". Version not supported

or 

QIS_Warning
Failed to use memory map "abc". File is corrupted.

Previous versions of QIS would crash if it could not find the display or other missing X-windows support files. This has been fixed.

Previous versions of QIS were subject to a slight delay after the GDSII file had been opened and the Open_GDSII was complete. Instead of responding to a command QIS would return:

QIS_Warning\n
GDSII open in progress, command ignored.\n
Get_DBU\n

This forced the client to introduce a short delay prior to issuing a command after an Open_GDSII. This has been fixed.

The 32 bit version of Linux is now compiled on RH Enterprise 3.0. This should be compatible with 7.x versions of RH as well as the 3.0 version.

Previous versions would generate a "Memory error occurred during loading" error if Set_Load_Memory is set to on and the GDSII file has multiple XY records inside a boundry, path or box entity record. Multiple XY records are syntactically incorrect in GDSII.

This version would generate a warning for multiple XY records for boundary, path and box after scanning. e.g.

QIS_Warning
Illegal data at file positions:
XY Coordinates,1329668144

The first XY record would be used, all other XY records in the boundary, path or box would be ignored.

In addition to the previously documented commands, these commands will do nothing under no display mode:

Set_Layers_Outline_Color
Set_Layers_Fill_Color
Set_Layers_Fill
Set_Layers_Outline_Type
Set_Layers_Map_File
Set_SDF_Color
Set_SDF_Outline_Color
Set_SDF_Fill_Color
Set_SDF_Fill

Previous versions would output text vectors with extents box as (0,0) (0,0) under no display mode. This has been fixed.

Structure extents returned by Get_Structure_Extents are now transformed by the Set_Transformation settings on the queried structure. It used to output the original GDSII file's structure extents disregarding the transformation settings set by the user.

The keywords returned by these 2 commands, as well as the GDSII_Tcp_Data keyword, are changed from lower case (Gdsii) to upper case (GDSII).

Previous versions would output a GDSII file with a different unit than the original file it was created from. This has been fixed.

If there is a distance of exactly 16384 DB ticks between consecutive coordinates in a boundary or path, previous versions of QIS would report the data with corrupted coordinates. This has been fixed.

This version uses the background color (Set_Background_Color) as the background color of black and white Tiff output.

When creating and saving the load memory map, QIS sends out progress messages if Set_Progress_Message is on. The message says:
Saving... 58%

No progress message for creating scan memory map which tends to be very fast for normal GDSII files.

In the previous versions of QIS, it rounded a corner
pixel of the triangle in high resolution bitmap(TIFF)
output to the next pixel always. This behaviour is
exemplified with the following triangle.

     x <- this pixel is rounded to the next one.
   xx
   xx
  xxx
  xxx
 xxxx
 xxxx
xxxxx

where, x is a pixel.

QIS has been fixed and the above triangle is drawn
the way it should be as shown below.

    x
   xx
   xx
  xxx
  xxx
 xxxx
 xxxx
xxxxx

This version supports memory maps for scanning. Use Set_Use_Memory_Maps, Set_Create_Memory_Maps and Set_Memory_Maps_Dir to control the usage of memory maps.
In addition to the load memory maps, a scan memory maps file will be generated or used based on these file names:

Windows/Linux Solaris/HP-UX
32 bit demo1.gds.scan.l32 demo1.gds.scan.b32
64 bit demo1.gds.scan.l64 demo1.gds.scan.b64

Here is a comparison between a normal scan/load time to a new scan/load time after a memory map has been saved.

GDSII
Size      Normal    Memory Maps
(MB)    Scan  Load   Scan  Load
314.6     23    46      0     7
417.5     24    25      0     5
496.2     39    53      0     9
679.5     53    72      0    13
693.9     41    43      1     7
766.6     46    48      1     5
1058      78    75      0     7
1631.3   117   163      1    22
1862.2   137   140      0    17
1985.4   145   143      0    14
2075.2   128   193      0    41
3797.3   219   231      0    24
4710.6   237   343      0    34
14177.7  889  1079     13    83

QIS_Warning\n
Memory map 'demo1.gds.load.b64' is not used (different layer map settings).\n

Older versions might generate a Tiff output with an incorrect 1 pixel line on the left edge. This has been fixed.

This command starts a new database using the specified grid and unit as if an empty file has been opened. The previously opened file, if any, would be closed.

This command closes a previously opened GDSII file as if no file has been opened. It releases memory and unlocks the GDSII file so the file can be modified or removed by other programs.

Previous versions always process GDSII box data as if they are boundaries, they are always drawn. This version does not draw box data because according to the GDSII definition, box data are not layout data. Use this new command to turn on to draw box data as if they are boundaries.

This command controls whether to output only vectors which are entirely enclosed in the current window. If it is on, only vectors entirely enclosed in the current window are output; if it is off, all vectors intersect with the current window are output.

This version of QIS generates a new version of load memory maps which are not compatible with previous QIS. Older load memory maps will not be used by this QIS. Load memory maps created by this QIS cannot be used by previous QIS.

This command now outputs the number of boxes per layer. e.g. layer-boundary:path:text:box 12-866:45:5:10

It reports an additional line for the number of box in the GDSII file.
The number of lines of report is now 17.  e.g.

Get_QIS_Report
17
Number of Structures: 7
Structure References: 25
Array References: 0
Boundaries: 83 (81,2,0)
Boxes: 5 (3,2,0)
Paths: 18 (10,0)
Vertices: 461
Texts: 6(--)
Estimated Memory for Load Data: 0.0MB (3248 bytes)
Total Memory for Load Data: -- (Load Mode is Off)
Data Dropped: -- (Load Mode is Off)
Scan Time:
  0 min 0 sec (elapsed time)
  0 min 0 sec (CPU time)
Load Time:
  0 min 0 sec (elapsed time)
  0 min 0 sec (CPU time)

Previous versions might output empty structure extents as (2147483.648,2147483.648,-2147483.647,-2147483.647). This version output (0,0,0,0).

New commands were added to this new release. Please check the Documentation section for more detailed information about each command.
Here is the list of new commands:

• Interrupt Scan/Load
• 256 Colors support.
• Hierarchical Output in the extraction module.
• Structure Display Filter Outline/Fill Color
• Transformation per Structure
• Set Input Layer Map
• Set Output Layer Map

With the new functionality to stop opening a GDSII file, the new QIS behavior might prompt a problem in the client program. Changes might need to be made to the client program for it to work with this new QIS release. Please refer to "Scan/Load Interrupt" in the New Functionalities section.

Memory Error Occurred During Loading when Layer/Datatype were out of range.
If there are data with layer or datatype numbers not in the range of 0 to 1023, QIS 2.xx versions would generate a "Memory error occurred during loading." error during loading and the file is not loaded.
Pre 2.00 versions would load the file but the data with layer or datatype outside the range would be missing from the drawing.
This version would map layer or datatype number outside 0-1023 to a number which is the modulus of the original number. e.g. Layer 6005 becomes 885.

Tiff extraction module had a bug for the polygons, which form a non-horizontal, non-vertical line in the final high resolution bitmap image. This has been fixed.
In general, the speed of extraction module has been improved by 2x.

With the new functionality to stop opening a GDSII file, the new QIS behavior might prompt a problem in the client program. Changes might need to be made to the client program for it to work with this new QIS release. Please refer to "Scan/Load Interrupt" in the New Functionalities section.

If a boundary, path or text has no layer or datatype property, it is default to be 0. Previous versions used the last known layer or datatype from the previous data.

Undelete_Vector now works for newly added data also. Use this command to undelete a previously-added-then-deleted data by passing in the vector handle to the data. e.g.

Undelete_Vector\n
TOP,N36\n

This version includes the ability to process a GDSII file and write the quad tree memory map to a disk file. The ability to write a quad tree to disk and later to read it directly from disk to memory is of value when the same file will be opened many times without modification.

When opening a GDSII file for viewing, QIS must first scan the file to determine the hierarchy and to build a list of structures. This scan data is placed directly in memory. A second pass through the file is used to build a quad tree which previously was also placed directly in memory. Only after the scan and quad tree were built could display begin.

This version of QIS now enables the "client" to instruct QIS to write the quad tree data to disk. Upon opening the GDSII file at a later time, the QIS can use the quad tree on disk rather than re-calculating it. For large files where the calculation of the quad tree takes many minutes this is a definite advantage.

This version does not yet write the scan data to disk -- hence each time a GDSII file is opened it must be re-scanned. The next version of QIS will support both scan and quad tree memory maps.

New Commands (see documentation pages ...)

Set_Memory_Maps_Dir
Set_Create_Memory_Maps
Set_Use_Memory_Maps

This is the first release that has basic GDSII editing. Some notes (see documentation page for details)

• GDSII data must be loaded into RAM for editing -- there is a new API command to force this.
  
• Entities may be added or deleted from existing structures.
  

this is the first official release of QIS that includes a quad tree approach to handling GDSII files. Instead of loading the complete GDSII data file into memory, QIS 2.00 creates a quad tree map of the file and stores that in memory. GDSII data is read directly from disk as needed for the display.

Benefits include: larger files can be handled since the quad-tree map is typically smaller than the GDSII footprint in memory. The RAM required for the quad-tree varies but one can typically estimate about 30% of the GDSII file size.

Once zoomed in, the quad tree implementation pans and zooms much faster.

New commands, originally done on windows for extracting GDS output and getting high resolution bitmap (packbit tiff format), have been ported on all other platforms.
Refer to documentation for the details of these new commands :
Get_Gdsii_Tcp, Get_Gdsii, Get_Hires_Image_Tcp, Get_Hires_Image.

On successfully starting at certain port number, QIS is suppose to send a message specifying the port number to standard error pipe(stderr). In case, where QIS is asked to select port number on its own( qis -port 0 , refer QIS v1.33), QIS sends the correct port number it starts on. However, if QIS was asked to start on specific port number( qis -port 6666 ), then it use to send incorrect port number to the pipe and internally use the correct specified port( in this case, 6666). This wrong behaviour has been fixed so that QIS sends the correct port number to the pipe as well.

A new high resolution image rasterizer module has been added. This rasterizer enables QIS to produce monochome bitmaps up to 10,000 x 10,000 pixels and the primary usage is to work in conjunction with wafer inspection equipment. The high res bitmap is in TIFF format with packbits compression and can be sent back through a TCP/IP stream or written to a file.

QIS Windows updated to 1.34 from 1.07. All the commands which were available in the UNIX version, are now available with the Windows version.

This sends a request to QIS to get the flat GDS data in the current selected window(set by set_window or set_exact_window). Data is clipped at the window boundary. If the input file is hierarchical, the output file is flat. This command disregards all the display filters and gets you all the data. All output entities are boundaries. Any paths(non-zero width) are reduced to boundaries. However, paths with zero width are ignored. Output file top structure name is set to TOP. Entities are output on the same layer as the input entities. The GDSII output file unit and resolution matches to that of input file.
The Gdsii output file is sent over TCP/IP.

This also extracts the GDSII data in the current window and the output file characteristics are similar to those explained in Get_Gdsii_Tcp command. The only difference is that this command requests QIS to write GDSII data to the file instead of sending GDSII data over TCP/IP as in Get_Gdsii_Tcp. This command helps if the client and QIS are running on the same machine and if client plans to write the GDSII output data to some file.

A new sample QIS client is now available with more commands and the C code used to write it.

User can specify the output file name for the extracted GDS data, which QIS sends in response to "Get_Gdsii_Tcp". Please refer to QIS update report for details of Get_Gdsii_tcp command.
Example:
Get_Gdsii_tcp
2048000

In this case, QIS will respond with GDS data in chunks of 2048000. If you specify '0' as a parameter then QIS sends GDS data in the default size of 1024000.

QIS selects the port number automatically when it is started with port number 0.

In general, port numbers vary from 0 through 65535.

0       - 1024 are "well-known" or "reserved" port numbers.
1025  - 49151 are "registered" port numbers.
49152- 65535 are "dynamic" port numbers.

QIS starts on the first available non-registered or dynamic port number.

If non-zero port number is passed to QIS then it makes an
attempt to start server at the specified non-zero port number.

On successfully starting, QIS sends a following message to stderr
(Standard error pipe).

QIS Startup Status(0)
Port Number(Port_Number)

where Port_Number is the port number on which server has successfully
started.

In case of error it sends similar error message to stderr,

QIS Startup Status(Error_Code)
Error_String

where,
 "Error_Code : Error_String" pair is one of the followings,

 2 : QIS failed to start at the specified port number and IP address.
 3 : License_Error
      where,
      License_Error is the detailed licensing error.
 4 : Either the colfill.pat file does not exist in the qis directory or
      it cannot be loaded.
 6 : Either the gdsfont.shx file does not exist in the qis directory or
      it cannot be loaded.
 7 : QIS failed to open the display.

In case of QIS (NTI) license error, detailed "Synopsys license error"
is sent to stdout and our following error message is sent to stderr,

QIS Startup Status(3)
License error.

Structure Display Filter Color and Fill Pattern Older versions might crash when getting a license because of the version string "2004.3". This has been changed to "2004.03" and the crashing problem has been fixed.

Structure Display Filter Color and Fill Pattern Structure references filtered out by structure display filter are represented by an extent box of the structure. The color and fill pattern of these references can now be specified through these 2 new commands - Set_SDF_Color and Set_SDF_Fill. e.g.

Set_SDF_Color\n
65535,30000,16384\n

Set_SDF_Fill\n
32\n

The color is specified in RGB values ranging from 0-65535. The fill pattern is an index of a fill pattern as specified in colfill.pat.
Default is solid fill (fill pattern index 1) with color 35000,0,0. The fill pattern is used to fill the extent boxes in both fill and outline draw mode. One can use fill pattern index 0 to specify no fill.

The various pixmaps are resized to be exactly as specified in Set_Image_Size.

Set_Exact_Window\n
x1,y1,x2,y2\n

Use this command to set the window to be exactly as specified. QIS will not adjust the coordinates to have the same aspect ratio as the image size. After this command is set, vector data will only be returned if the data is inside the window. This command can be used to get data in an area which is not of the same aspect ratio than the image size. If this command is used to set the window, the window should be reset using Set_Window before a redraw; otherwise, the image will only be drawn within the non aspect ratio area.

Structure references are filtered out and represented with an extent box if it's extents width and height are both smaller than the structure display filter size. Older versions use just the width or height. So, for the same settings, this version could be slower because long and thin references are not filtered in this new version.

More Colors Support For Outline Color and Fill Pattern Color Additional colors can be added to colfill.pat using RGB values. RGB range is 0-65535.

After QIS starts up, send this command to get if there are any outline
colors and fill pattern colors that were not allocated successfully.
e.g.
Get_Color_Errors\n
51,52,53\n
84,85,86,87,88\n
This means outline color 51, 52 and 53 are not allocated, they are
default to white.  And fill patterns 84, 85, 86, 87 and 88 are not
allocated.  They are default to the original 0-7 color as specified in
colfill.pat.
If there are no color errors, the response from QIS is:
Get_Color_Errors\n
\n
\n

Get the number of boundaries, paths and texts per layer.  The numbers
are before explosion counts, not after.  Only per layer counts, no
layer/datatype discrimination.  So data on layer 1 datatype 2 and layer
1 datatype 5 are both counted for layer 1.
Syntax is layer-boundaries:paths:texts
e.g.
Get_Data_Number_Per_Layer\n
0-1:0:1369,1-545:0:0,2-158:0:0,3-2265:35:0,4-1872:363:0,5-186:0:0\n

Added the number of lines of report.  e.g. There are 16 lines of report:
Get_QIS_Report\n
16\n
Number of Structures: 7\n
Structure References: 25\n
Array References: 0\n
Boundaries: 83 (81,2,0)\n
Paths: 18 (10,0)\n
Vertices: 461\n
Texts: 6 (20)\n
Estimated Memory for Data: 0.0MB (3248 bytes)\n
Total Memory for Data: 0.0MB (3248 bytes)\n
Data Dropped: No\n
Scan Time:\n
  0 min 0 sec (elapsed time)\n
  0 min 0 sec (CPU time)\n
Load Time:\n
  0 min 0 sec (elapsed time)\n
  0 min 0 sec (CPU time)\n

More Colors Support For Outline Color and Fill Pattern Color Older versions would draw the fill patterns upside down while they look correct in the layer dialog box. This has been fixed.

This version uses a new licensing scheme which checks for ICWB license. Solaris 32 and HPUX 32 versions are dropped.

This version could use up to 75% less memory comparing to previous versions. e.g. Memory usage of 1GB could be reduced to 250MB. This would be true if the GDSII file has polygons with more than 4 vertices and are manhattan data.
Memory saving might also result in less swapping and thus would speed up the overall performance drastically depending on the system's RAM size.

The last HPUX 64 bit version would output invalid numbers for negative coordinates in vector mode if the unit is DBU. This has been fixed.

This works similar to Get_Structure_Children which output a list of structures which the specified structure references. In addition, it output the number of references for each structure. e.g. child1,5,child2,10 which means child1 is referenced 5 times, child2 is referenced 10 times.

Added a no display mode to QIS so it can be run on systems with no DISPLAY specified. To run QIS in no display mode, specify -nodisplay as a command line option.
In no display mode, only vector data can be accessed, no image drawing will be allowed. The only different behavior in no display mode is the Set_Window command will set any window given, not resized to the aspect ratio of the image size as in normal display mode.
These commands will do nothing under no display mode:
Redraw
Zoom_Home
Set_Image_Size
Get_Image
While other commands might be meaningless under no display mode, like Set_Fill, they are still processed by QIS.

Previous versions use and remember layers' color, fill pattern and line type in the file gdsplot.map in the startup directory. This version default to not use a gdsplot.map file. To set QIS to use gdsplot.map, use Set_Layers_Map_File\nOn\n. To turn it off, send Off.
When map file is off, everytime a file is opened, default colors and solid fills are used and line types are default to 1 (on with 1 pixel). Setting the layers' colors, fills and line types via Set_Layers_Outline_Color, Set_Layers_Fill and Set_Layers_Outline_Type will change the layers' properties. These changes are not saved in a file. When another GDSII file is opened, default settings will be set for the new file's layers. When map file is on, settings from a gdsplot.map file is used when a file is opened. Settings are saved to gdsplot.map when any of the above three Set_Layers_*** commands are used.
You can turn on/off map file anytime, does not have to be at the beginning of the program.

The loading time has speed up when sort data by layer is turned on especially under Solaris.
Older versions would order text data first even if their layer is larger than the other data. This has been fixed.

QIS 1.25 includes a new structure display filter. All structure references smaller than the specified structure display filter size (in pixels) are drawn with an extent box. Internal details appear once the user zooms to the point that the reference extents exceed the the filter size. The default setting for the structure filter is 20 pixels. The structure display filter uses a dummy fill for structures that have been filtered out, giving the user a better view of the layout even for large filter values. This enables the user to keep the filter value large (20 pixels) which can greatly speed up the display speed.

To display all details at all zoom levels, set structure display filter = 0.

The entity display filter still has precedence over this structure display filter. It is normal to set the structure display filter to be considerable larger than the entity display filter.

The New QIS API command is: Set_Structure_Display_Filter_Size, to set the structure display filter size in pixels.

Get_QIS_Report reports the CPU time for scanning and loading in addition to the elapsed time. The CPU time is user time plus system time. This is available in UNIX and Linux and is useful for profiling and benchmarking.

In a wide area network environment, QIS might require as long as 60 seconds to start due to the method that was used to create fill patterns. This has been corrected.

Previous verisons of QIS on Solaris 64 would crash when using the X-server on Linux display. This has been fixed.

QIS 1.25 has been successfully ported to HPUX 11 64 bit.

v1.22 would crash when a command to get a non-existence structure's info is sent to QIS. This has been fixed.

Storing and accessing cells in memory is much faster and efficient. For most files we see improvements in scanning and loading of up to 10-15 percent. But for files with large number of cells or cell references we saw major speed improvements of up to 30x.

Previous versions of QIS would stop scanning and hang up if the GDSII file had more than 2 billion This version has a new structure names finding routine which would speed up scanning and loading 10+ times depending on the similarity of the names and the number of structures.

QIS sends out the drawable (win or pixmap) handle when it acknowledges a Set_Image_Size command. e.g. QIS sends out

Set_Image_Size\n
119234567\n

The Set_Image_Format command can be used to tell QIS not to send out a GIF image after redraw finishes. e.g.

Set_Image_Format\n
Off\n

Set_Image_Format\n
GIF\n.

Added Set_Draw_Window_ID command to send a client's window handle to QIS and let QIS draws directly to the client's window. To make QIS back to draw to a pixmap, send -1 as the argument. With this turned on, Get_Image should not be used and the window handle from Set_Image_Size would not have a valid picture.

Previous versions of QIS would stop scanning and hang up if the GDSII file had more than 2 billion boundaries/paths or total number of vertices. The 32 bit version of QIS has been fixed to issues an error message and quit gracefully. It is expected that files of this size will generally require QIS 64 which can address much more memory.

QIS_Error
X.XXGB of memory is needed to view bigfile.gds.
Maximum memory is 4GB.

Forces QIS to use the local machine's display for pixmap creation for drawing, specify the $DISPLAY environment variable before launching QIS. e.g.

export DISPLAY=localmachinename:0

Using the local X server can result in much faster performance when a remote display has been invoked by the client.

Reduced the period of TCP/IP socket polling from 300 milliseconds to 5 msec. Tests shown with clients indicate that polling of 5 msec significantlyl reduces the apparent display latencey without significant overhead penalty.

The function that converts pixmap to GIF has been improved thus improving the speed when a GIF image is returned to the client.

For GDSII files with a large number of structure references, this version uses less memory during scanning and scans the file faster.

Previous versions has 2 separate sets of layer settings, one for just layers only, another set for defining layer:datatype combinations.  If only layer 9 were turned on, it would switched to use layer 9 color instead of layer 9:20 color, which appeared as a color error to the users.

In this version, layer related commands have been modified to use just a single set of settings for all layer:datatype.  Specifying a layer number, without the datatype, selects all layer:datatype combinations for this layer number.e.g.

Set_Layers_On\n
9\n                means turn on layer 9:2, 9:20 and 9:30.

These following coommands are affected by this change:

set_layers_outline_color
set_layers_fill
set_layers_outline_type
set_layers_on
set_layers_off
set_geometry_marker

When this command is set "on" data is loaded in layer order on a per structure basis. The command must be set "on" prior to opening a file. Changing this setting once a file has been opened has no effect until the file is reopened.

Using this function will slow down loading time; scanning time and drawing time should not be affected.  More memory will be used during loading but the total memory used after loading should remain the same when comparing to no layer sorting.

New Command Set_Vector_Grand_Parents
Turn this on to get the grand parent structures.

New Command Get_Window_Info
Get all data within the specified window area. Data are within the window when paths or boundaries have vertices inside the window area, texts and structure references have insertion point inside the window area, or when the structure outline are turned on, at least one of the four corners of the outline extent box is within the window area.
This works very similar to Get_Vertex_Info except it takes a window area instead of a point. The coordinates are in DBU or user units depending on the Set_Vector_Unit.

New Command Set_Vertex_Info_Radius
This sets the search radius in screen pixels for Get_Vertex_Info. The default is 4 pixels.

Array/Row
Update to support array row, column for short form array vectors.

New Command Set_Reference_Vector_Format
Use Set_Reference_Vector_Format to control whether to QIS returns structure reference vectors in long form or short form. 

short form -- only the type (array or single structure reference), insertion point, scale, rotation and mirror are generated.  e.g. S,TOP,10.0,20.0,1.5,0.0,X

long form -- no change from previous versions: the parent structure, the bounding box and the rows and columns are added. Use the keyword Long or Short as the argument to the command. Default is long form.

Numerical Product Name/Number
For Numerical, use product number 6555 for keycodes generation. So the product name is changed to ACS6555 for the purpose of FLEXlm keycodes generation.  One name/number for all platforms.

Numerical Multiple QIS with 1 License
the Numerical specific version of QIS allows multiple instances; i.e. a single workbench instance may require multiple QIS instances.

Flexlm Licensing
Added support for flexlm licensing to the Linux version of QIS so that Numerical can begin to use it in beta evaluations.

Nesting Level 0
Added control to set nesting level to 0 which means no data are processed in the specified structure.

In connection to this, one can specify to outline and/or label the specified structure on nesting level 0. The outline will be the extent box of the structure and the label will be centered within the extent box.

In general, all commands with nesting level controls are changed. In version 1.01, 0 is used to set all levels, now it is the keyword All. And now 0 means level 0.

Commands changed:

1. Set_Nesting_Levels
   Argument is now All or a nesting level number >= 0.
   Error messages:
   a. Missing argument - All|1 number(s)
   b. Invalid argument.  Argument format - All|1 number(s)


2. Set_Structure_Outline and Set_Structure_Labels
   Argument is now Off or All or a list of nesting level numbers >= 0
   separated by commas.
   Error messages:
   a. Missing argument - Off/All/list of hierarchy level(s)
   b. Invalid argument.  Argument format - Off/All/list of hierarchy level(s)


3. Get_Structure_References
   Arguments are structure name; then All or 1 to get all or just the first
   reference; then All or a nesting level number >= 0 to specify the nesting
   level, this third argument is optional.
   Error messages:
   a. Invalid argument.  Argument format - string,All|1,All|number
   b. Missing argument.  Argument format - string,All|1,All|number
   c. Missing structure name
   d. Structure 'ABC' does not exist


4. Get_Structure_Tree
   Arguments are structure name, then All or a nesting level number >= 0
   to specify the nesting level, this second argument is optional.
   Error messages:
   a. Invalid argument.  Argument format - string,All|number
   b. Missing structure name
   c. Structure 'ABC' does not exist

Wrong Layer Numbers Result in Blank Drawing
Previous versions would return a list of layer numbers with the datatype numbers always 0 when Get_Layer_List is received for the first time after start up. This caused subsequent layer controls to use the wrong layer:datatype numbers and so no layers were turned on and so a blank drawing is generated. This has been fixed.

First Linux Release
QIS 1.01 is the first release available for Linux (Red Hat 7.2).  QIS on Linux does not support Lserv network licensing, only nodelock. It will support FlexLm network licensing in the very near future as we are converting over to Flexlm at this time.

Get_Structure_References New Syntax
The Syntax for Get_Structure_References has been changed:

Get_Structure_References\n
structure_name,All or 1,nestinglevel\n

where:

structure_name           name of the structure for which you wish to
                         find the instances. The search starts at wherever
                         the program is currently located in the hierarchy.
                         You would normally expect to be at a point in
                         the hierarchy that is above the level of the
                         structure that you are investingating.

All                      return all references to this structure no matter
                         how many there are.

1                        returns just the very first instance and then stops.

nesting_level            how deep down the hierachy to look. If not specified,
                         the default is to use whatever has been
                         set using the Set_Nesting_Level command.

The server returns the same data as the Get_Vector command returns return but only the refences information. If for some reason a refernce to an "empty" structure is encountered, this is not returned.

New error responses: If the second argument is neither ALL or 1 or the 3rd argument is not a nesting level (i.e. an integer 0,1,2,3...)

QIS_Error\n
Invalid argument.  Argument format - string,All|1,number\n
Get_Structure_References\n
ABC,Junk,Junk

or if the 2nd argument is missing:

QIS_Error\n
Missing argument.  Argument format - string,All|1,number\n
Get_Structure_References\n
ABC

New Command - Get_Structure_Tree
This new command has been added in order to help a client display or to navigate through the structure hierarchy. Similar to the Get_Structure_References, but the entire tree information is provided. You can think of Get_Structure_References as just returning the leaves; Get_Structure_Tree returns all of the branch information in addition to the leaf information.

Get_Structure_Tree\n
structure_name,nestinglevel\n  

where

structure_name                 starting point for the tree

nesting level                  optional. If not specified defaults
                               to current value of nesting level.

All references are output, the current viewing window and current array mode settings do not filter out the output.

Error Response checks for a valid argument in the form of a string first and then a nesting level integer ...

QIS_Error\n
Invalid argument.  Argument format - string,number\n
Get_Structure_Tree\n
ABC,Junk\n





QIS Exits With Error - License Not Released
Bug Fix. Previous versions would not release the license token back to the license server if QIS cannot be started on the specified port and/or IP address; or if QIS cannot open a handle for the X11 display. This has been fixed so that the license token is returned immediately.

Fixed a bug in QIS that drops 1st Argument of the Command
Occasionally a previous version was found to drop a single byte of a command that turned out to be a critical argument. -- therefore QIS generated a missing argument error message when in fact the client actually had sent the so called missing argument. This has been fixed.

No GUI - better speed
This version has the GUI taken out. It is just an exe running with no GUI.
Without the GUI, QIS has 5-10% of drawing speed improvement.

New command - Set_Time_Out and Set_Marker_Shape
Use this command to tell QIS to wait for X seconds and then automatic exit after the client has disconnected, crashed, etc. Pass the number of seconds to wait as the argument, or 0 to not exit. Default is not to exit.

New command - Set_Marker_Shape
Use this command to set the marker shape to diamond or x. Pass Diamond or X as the argument. The size for X is 21 pixels by 21 pixels. Default is diamond.

Changed commands - Set_Geometry_Marker
On/Off/list of layers:datatypes Set this to On to draw a marker at the starting point of all paths and boundaries. Set this to Off to not draw geometry marker. Specifiy the layers or layers:datatypes so geometry markers are only drawn for data on those specified layers if that layer is turned on by the Set_Layers_On or Set_Layers_Off commands. Similar to the layer commands, in this Set_Geometry_Marker command, if a layer is specified with datatype (1:20) and the current settings does not have datatype turned on, it will turn on datatype. And vice versa for just layer number specified in the command.

Changed commands - Set_Progress_Message
Scanning and loading percentage messages are sent every 0.5 second.

New Error/Warning Messages

1. Errors after Open_GDSII:
   a. If detected memory to load the GDSII file is over 4GB.
      QIS_Error\n
      xxxGB of memory is needed to view /fullpath/xxx.gds.\n
      Maximum memory is 4GB.\n
   b. If system does not have enough memory to load the GDSII file, the
      memory needed is report in GB or MB.
      QIS_Error\n
      x.xxGB of memory is needed to view /fullpath/xxx.gds.\n
      The system does not have enough memory.\n

      or

      QIS_Error\n
      x.xMB of memory is needed to view /fullpath/xxx.gds.\n
      The system does not have enough memory.\n
   c. If the file cannot be opened.
      QIS_Error\n
      The selected file 'xxx.gds' is invalid or empty.\n
   d. If the file does not start with 0602, then it is not a GDSII file.
      QIS_Error\n
      The selected file 'xxx.gds' is not a GDSII file.\n
   e. If the GDSII file does not have any structure definition.
      QIS_Error\n
      No structure defined in the GDSII file.\n
   f. If there is a memory related error during scanning.
      QIS_Error\n
      Memory error occurred during scanning.\n

   Warnings after Open_GDSII, the GDSII file can still be scanned and
   loaded successfully but the data might not represent the original
   intended design (e.g. a truncated GDSII file):

   a. If a data/GDSII record cannot be read from the file completely,
      the file might be truncated.
      QIS_Warning\n
      Incomplete data at file position 123456, file might be truncated.\n

   b. If end of library does not exist in the GDS file.
      QIS_Warning\n
      Missing end of library.\n

      The file will be treated as if the GDSII library ends at the end
      of the file.  The file can be scanned and loaded successfully.
   c. If a structure is not ended with an end structure.
      QIS_Warning\n
      Missing end of structure for structure 'ABC'.\n   

      The open structure is artificially ended at end of library.
   d. Structure definitions inside a structure.
      QIS_Warning\n
      Illegal structure definition at file positions:\n
      ABC,24\n
      DEF,789\n
      JUNK,55987\n

      These structure definitions are ignored and all data that comes
      after such structure definitions belong to the structure definition
      before it.  Only the first 20000 illegal structure definitions are
      reported.  e.g.

      Structure Definition ABC
      Path 1
      Boundary 1
      Structure Definition DEF
      Path 2
      End of Structure

      DEF is ignored and path 2 belongs to ABC.

   e. If an end of structure does not have a preceding structure definition.
      QIS_Warning\n
      Illegal end of structure at file positions:\n
      248\n
      77668\n

      These end of structures are ignored.
      Only the first 20000 illegal end of structures are reported.

   f. If any data/record is defined outside of a
      structure definition-end structure, the data are ignored.  e.g.
      
      QIS_Warning\n
      Illegal data at file positions:\n
      Boundary,123\n
      Layer,177\n
      Path,456\n
      Width,480\n
      Text,789\n
      Structure Reference,4321\n
      Structure Reference Name,4330\n
      Array Reference,6677\n
      Path,9900\n
      Path,11000\n
      Path,33333\n

      Only the first 20000 illegal data/record are reported.

   g. If there are structures referenced but not defined in the GDSII file.
      QIS_Warning\n
      Undefined Structures\n
      StructureABC,StructureXXX\n

   If there are QIS_Warning, Open_GDSII will still be sent to mark a
   successful file open.  If there are QIS_Error, Open_GDSII will not be
   sent because the open failed.

Crash During Scanning/Loading
Older versions might crash with "Process 1234 terminated by signal 11" if the selected GDSII file is not a perfectly legal format. This has been fixed, and errors/warnings are added to inform users about any illegal data in the GDSII file after scanning.

Wrong Color In GIF Images
Older versions might have 1 color in the GIF image drawn as another color. This has been fixed.

Coordinates Unit
In addition to vector data, all coordinates for all commands are in the specified unit (database unit or user unit). The unit is set by using Set_Vector_Unit (DBU or UU).

Here is the set of commands which has data in the specified unit:

Set_Window
Get_Window
Get_Image
Image_Ready
Get_Structure_Extents
Get_Vector
Get_Vertex_Info
Get_GDS_Vector
Get_Display_Vector
Get_Structure_References


Default Image Size
Default image size is 800,600 for all platforms. However, the client should be setting the image size accordingly depending on the client viewing area size.

Startup Files
It uses gdsfont.shx and colfill.pat in the qis.exe directory, gdsplot.map in the current directory where QIS is started.

QIS Startup Error Exit Code

QIS exits right the way when these errors occurred during startup:
0 - No error
2 - QIS cannot start at the specified port and IP address
3 - License error
4 - colfill.pat in the qis.exe directory does not exist or cannot be opened (no error messages)
5 - Out of system resource error, fill pattern bitmaps cannot be created (no error messages) (Windows Only)
6 - Font error, either the gdsfont.shx does not exist in the qis.exe directory or the font file cannot be loaded (no error messages)
7 - Cannot open display (UNIX Only)


QIS Startup Error Exit Code

2 - QIS cannot start at the specified port and IP address, or, no port and/or IP address are specified when QIS is launched.
3 - License error. The error message is printed to the command window for UNIX and the error message is shown in a pop up message box under Windows.

Wrong Get_Image Picture
Under Windows, older versions might return a picture of the desktop if Get_Image is used after a Open_GDSII and before a redraw. It has been fixed to return a blank picture.

Structure List
Get_Structure_Children and Get_Structure_List have significant speed improvement (10 to 30+ times faster) when the number of structure names return are over 10,000. e.g. 30,000 names in 4 seconds vs 1 minute 10 seconds.

Duplicate Structure Definition
If there are structures defined more than once with the same name, this warning is generated after scanning:

QIS_Warning\n
Multiply-defined structures\n
StructureABC,StructureXXX\n

New Command Get_GDS_Vector
This command returns all data regardless of the display filter value and blank line type as long as the extents of the data overlap the current viewing area, the layer of the data (boundary, path and text) is turned on and the structure references is within the specified nesting level. This command is intended for use when the client does not necessarily want to display data on screen but will do certain manipulations such as sizing, OPC etc ....

Get_Display_Vector
In release 0.7 this command is identical to Get_Vector.  Data is filtered    by the display filter.  In future versions, we plan to this command will output    data optimized for driving a display and will be more compact than Get_Vector

Get_Structure_References
This command requires a structure name as the argument and returns all the SREFs that fall within the current viewing structure.  SREFS are not filtered out by the display filter but they are filtered out if they are deeper than the specified nesting level.

Get_QIS_Report
This returns statistics on the GDSII file as well as the memory used to store it. QIS will return:

   Get_QIS_Report\n
   Number of Structures: 47\n
   Structure References: 5427\n
   Array References: 510\n
   Boundaries: 5765 (1332,1260,2)\n
   Paths: 398 (145,87)\n
   Vertices: 52298\n
   Texts: 1371 (5702)\n
   Estimated Memory for Data: 0.6MB (668132 bytes)\n
   Total Memory for Data: 0.6MB (668132 bytes)\n
   Data Dropped: No\n
   Scan Time: 0 min 1 sec\n
   Load Time: 0 min 1 sec\n

If the report is not available (e.g. before a GDSII file is opened),  QIS sends out just the keyword - Get_QIS_Report\n

Get_QIS_Version
Returns to the client the QIS version.

   Get_QIS_Version\n
   0.07\n

If the version number is not available (some errors), QIS returns    just the keyword - Get_QIS_Version\n

Modified Set_Image_Size
client can now request any size screen display independent of the available window size of the machine that the server runs on. For example the client can now issue the command:

   Set_Image_Size\n
   3000,2000\n

If QIS cannot reallocate memory for the new image size, the old size is kept and this error is returned:

   QIS_Error\n
   Memory error occurred when resizing image\n
   Set_Image_Size\n
   2345,1234\n

If successful, after resize, QIS returns:

Set_Image_Size\n 

There is, of course, additional computation required as the image size is increased so do not set an image size arbitrarily large.

With this change, this version of QIS does not show the picture inside the viewing area.  The "Draw To Screen" control in Windows is always turned off.

Default image size is 1000,1000 in UNIX and 1001,1001 in Windows; however the client should be set the image size according to the client's window size.

All pending commands are on hold during resizing and they are resumed after resizing. Therefore the client should not send additional commands to the QIS server until after receiving the Set_Image_Size acknowledgement.

Get_Vertex_Info Modified
This command has been modified to output data regardless of the display filter setting.

Get Vector Data handshaking modified
Each vector returned by QIS is now preceded by the keyword Vector_Data; instead of Get_Vector in previous versions of QIS.

When the stream of vectors is complete, the starting command is sent: Get_Vector, Get_Vertex_Info, Get_Display_Vector, Get_GDS_Vector or Get_Structure_References.

Exit code for Start Up
If QIS cannot be started using the specified IP address and port, it will exit with return code 2. If it starts up correctly it returns 0.

Open GDSII Acknowledgement
When Open_GDSII is received, upon the successful scanning and loading of the GDSII file an Open_GDSII\n string is returned.  If any errors occurred during scanning and loading QIS_Error is returned. Not all error messages have been implemented in 0.07.

New QIS Product Number
For UNIX, it is now 6000.  For Windows, it is now 6050. This means that Qckvu is no longer sharing the same license as QIS and older licenses for QIS need to be re-issued.

Improved Handshaking with Client
Previous versions of QIS did not respond to incorrect, incomplete or broken client commands. This version detects 3 kinds of error in the commands QIS receives from the client program - invalid keywords, wrong number of arguments or invalid arguments.  If there is an error for each command received, QIS sends an error command in this format:

QIS_Error\n
Error message\n
Original command received\n
Original command received.....\n

IP and Port Number Control
Added additional command line options to QIS to give the client more control over address and port behavior.

-ip

the -ip option enables the user to start QIS on the specified IP address in addition to specifying the port number. This is useful when there are more then 1 IP addresses (network adapters) on the machine

or

if you want to start QIS just for local machine connection (in which case specify 127.0.0.1 as the loopback IP address).

-port

with the -port option you control which port QIS listens on. You can now use the argument -port 0 and QIS will find the first available port rather than use a "hardwired" port.

Examples

To start QIS on default port and default IP address:

qis -port 0

To start QIS on specific port and default IP address:

qis -port 6789

To start QIS on default port and specific IP address:

qis -ip 200.123.321.1

To start QIS on specific port and specific IP address:

qis -port 6789 -ip 200.123.321.1

Use 127.0.0.1 as the IP address if you want to only allow local communication.

New Response from Get_Image & Image_Ready
Both commands return the coordinates of the window area that the image represents.  After the command keyword and the size of bytes to follow, the first 64 bytes contain the lower left and upper right coordinates which are presented in user units in this format llx,lly,urx,ury.  e.g.

Image_Ready\n
12345\n
12.500,50.000,80.050,120.005\0\0....\0   # 0 padded to total 64 bytes
Gif Image

OR

Image_Ready\n
12345\n
12.500,50.000,80.050,120.005\0\0....\0   # 0 padded to total 64 bytes
BITMAPINFOHEADER                         # 40 bytes
256 RGBQUAD Color Table                  # 1024 bytes
Bitmap Image

The purpose of returning the precise layout coordinates is to aid the client in building its own image map so that the user on the client side can perform functions such a zoom window or accurately select regions.

Structure Outline and Label
Set_Structure_Outline
Set_Structure_Labels


Use these two commands to control the drawing of a bounding box and structure name for structure references. This is useful when you want to present to the user an overview of the hierarchy but do not wish to show detail inside of the various structures.

The structure label is drawn starting at the insertion point.

Both these commands support hierarchy - to draw a bounding box for references on the first level of the current viewing structure, pass the parameter 1; for the second level, pass parameter 2.  Multiple levels can be also passed.  e.g.

Set_Structure_Outline\n
1,3,4,6\n

Set_Structure_Labels\n
2,5,6,7,12\n

The levels for labels and outline can be different.  Use 0 to set all levels, use Off to turn it off. e.g.

Set_Structure_Labels\n
Off\n

Text Height - The text height of the structure label is scaled on-the-fly to be approximately 9 pixels tall no matter what the zoom level is. If the extent of the structure is smaller than approximately 2 pixels, the label and structure outline outline may not be displayed: even if the display filter is set to 0.

AREF Rule - If a level deeper in an array reference is specified and the array mode is 0, then the outline or label is not drawn.  Array mode 0 takes precedence over outline and label.

Get_Vertex_Info
Use Get_Vertex_Info to obtain the "vertex" info of elements very close to a user specified coordinate.

Get_Vertex_Info\n
246.050,300.650\n

This command is similar to Get_Vector except that instead of returning all items in the entire display window, QIS returns only primitives that are within 4 screen pixels from the specified point. The search algorithm detects boundary and path vertices (not edges), text and structure insertion points(not the bounding box edges). If the structure outline bounding box is drawn or array reference mode is 0, then the 4 corners of structure references outline bounding boxes are also considered.

Set_Background_Color
Send this command with black or white to set the background color.

Set_Background_Color /n
Black /n

Set_Scale_Bar
This command is used to draw on screen a scale bar to show the distance in user units of approximately 100 screen pixels.  The bar adapts automatically as the zoom level changes.  When zoomed in very tight, the scale bar will be shown in 1 database unit in user unit (0.001um) as long as the scale bar is fully within the width of the viewing area.  If the distance of the scale bar cannot be determined (overflow or underflow), a "--" is shown with a fixed 80 pixel scale bar.

The scale bar can be placed in 1 of the 4 corners of the viewing area.  Send 1 of these controls - UL,LL,UR,LR to turn on the scale bar and specify it's location.  Send Off to turn off the scale bar. e.g.

Set_Scale_Bar\n
LR\n

or

Set_Scale_Bar\n
Off\n

Set_Get_Vector_Path
The client issues this command with argument "Boundary" to instruct the Get_Vector/Get_Vertex_Info commands to convert path output into a series of boundaries. Paths with no width and paths with 1 vertex are still output as paths.

To revert to returning vector data as paths send Set_Get_Vector_Path with argument "Path" .  This is the default behavior.

Fixed QIS Hang Problem
In previous releases QIS could get hung up if sends out data but the client is not reading them from the socket.  This version detects when the client is not reading the socket; in that case, QIS holds the commands and tries to send again 0.3 sec later.

Fixed Client Reconnection Problem
In previous release, a client that connexts to QIS and disconnects cannot connect to the same QIS again.  This has been fixed.

Windows Specific Issues

Open_GDSII Command no longer Re-opens the Display
Previous versions of QIS would pop open the server display window when Open_GDSII is received; even if it supposed to be minized.  This has been fixed.

Save View As GIF
Previous versions would generate a GIF output 1 pixel smaller than the display in QIS/Qckvu.  This has been fixed.

Upgrade to our Windows Sample Client Code
Added a Send Command dialog so that a client developer can type in any commands and arguments to send to QIS.  They can use this to demonstrate and test any QIS command.

This version of the client sample program will pop up the QIS_Error commands sent by QIS if there is an error in the commands QIS received.

New Option for Vector Coordinates
Added a new command Set_Vector_Unit to control whether to receive coordinates in database units(integer) or user units(floating point).

Set_Vector_Unit\n
DBU\n

to change the state of QIS to output database units, and

Set_Vector_Unit\n
UU\n

to change the state of QIS to output user units. If not specified the default is user units.

This unit applies for all vertex coordinates, path widths, insertion points, text extent boxes and structure extent boxes.  Note: Scale and rotation angle are always output as floating point values.




New Get_Vector Syntax
We have updated the return data from the Get_Vector command to make is easier to parse by the client. The parenthesis have been removed. The commas between vertex coordinates have been removed as the parser knows how many coordinates are coming.

Examples

Boundary Old Syntax:

Client: get_vector /n
Server: get_vector /n
        B,TOP,5:0,4(0,0)(10,0)(10,10)(0,10) /n

Boundary New Syntax:

Client: get_vector /n
Server: get_vector /n
        B,TOP,5:0,4, 0 0 10 0 10 10 0 10  /n

Text Old Syntax:

T,TOP,5:0,10,12,0,1.0,0.0,N,0,0,4(x1,y1),(x2,y2)(x3,y3)(x4,y4),"text string"

Text New Syntax:

T,TOP,5:0,10,12,0,1.0,0.0,N,0,0,4,x1 y1 x2 y2 x3 y3 x4 y4,"text string"

New API Command: Set_Layers_Outline_Color
Use this command to set a layer's outline color. the syntax is:

Set_Layers_Outline_Color
layer_num-outline_color_number

or

Set_Layers_Outline_Color
layer_num:data_type-outline_color_number

depending on whether you are in datatype mode (i.e. you are specifying datatype along with layer), or in layer mode (you are only specifying layers)

The available outline color numbers are 0-7.

You can set multiple layers with one command by separating the assignments with commas.

Set_Layers_Outline_Color
5-7,6-2,7-80,5,0

Do not mix datatype and layer type assignments:

5:0-7,6-2

is illegal.


New API Command: Set_Layers_Fill


Use this command to set a layer's fill pattern. The fill pattern is a value between 0 and 1024 and is an entry into the colfill.pat table. Syntax:

Set_Layers_Fill

layer_number-fill_pattern_number

or

layer_number:datatype-fill_pattern_number

Same rules for multiple assignments as Set_Layers_Outline_Color.


New API Command: Set_Layers_Outline_Type


Use this command to set a layer's outline type. For display this is either 1 or 0 where 1=show the outline and 0=don't show the outline. Syntax:

Set_Layers_Fill

layer_number-outline_type

or

layer_number:datatype-outline_type

Same rules for multiple assignments as Set_Layers_Outline_Color.

Example

Set_Layers_Outline_Type
0-1,1-1,2-1,3-1,4-1,5-0,6-1,7-1



New Command: Get_Colorfill_Pat


Use this command to obtain the colfill.pat file. This file contains a list of available fill patterns. This is an ascii file -- each entry has a number and is followed by a RGBCYMK bitmap that is either 4x4,8x8,16x16 or 32x32. These patterns are used to fill all boundaries on a given layer. Syntax:

Get_Colorfill_Pat /n

The server will first echo the command. The next line is the number of bytes to follow. After that the contents of the colfill.pat file are sent.



New Command: Set_Array_Mode


This command controls how arrays will be displayed. There are three modes:

0 - draws a "box" around the extents of the array
1 - draws the outer row and column cells
2 - draws the full array of cells.


Syntax:

Set_Array_Mode\n
0 or 1 or 2\n



Get_DBU


This command tells QIS to return the database information stored in the header of the GDSII file. Two numbers are returned.

1st number is the user unit resolution. For example if you are working in um and you set a resolution of 0.001 um then the first number would be 0.001. If you are working in mils and you need 0.1 mil resolution the first number will be 0.1.

Second number: length of a database tick in meters. In the first case since you need 0.001 um resolution 1 database tick is 10E-9 meter. In the second case, the number would be 2.54E-5 m because you need 10 of these to make one mil.

Here are some examples:

User's Setup                      GDSII DBU Info
micron, 0.001 resolution          0.001 ,  1E-9
micron, 0.25  resolution          0.25  ,  2.5E-7
mm      0.001 resolution          0.001 ,  1E-6
mil     0.1   resolution          0.1   ,  2.54E-5

New API: Get_Vector
This command tells QIS to output the details of all the data within the specified window area, in user units. Paths and boundaries are only output if:
1. They are in the view.
   
2. They are greater than the display filter.
   
3. Their fill,color,outline type attributes make them visible in the current view settings. (In outline mode, with line type 0, the boundary is not output.)

SREF and AREF info is only output if:

1. Any portion of the extents intersects the window.
2. The extents of the structure or array is greater than the display filter value.
3. The extents is greater than 0,0. (i.e. an empty structure.

All text strings are output if the string belongs to a structure qualified for output (see above.) Since we cannot know the font height we cannot accurately determine if the text string is smaller than the display filter size.

New API Command: Set_Reference_Marker


This command controls the drawing of the structure reference marker. This is a small diamond shaped marker locating at the SREF's insertion coordinate. Applies to raster data only.

syntax


Set_Reference_Marker
On | Off



Set_Geometry_Marker

This command controls the drawing of the entity reference marker. This is a small diamond shaped marker locating at first coordinate of the entity. Applies to raster data only.

syntax


Set_Geometry_Marker
On | Off



    Set_Text_Mode


This command controls the drawing of text.

Updated Commands

the following commands have been modified so that they no longer generate an automatic redraw.

1. Open_Structure
2. Set_Fill
3. Set_Outline
4. Set_Window




QIS v0.03 (03/01/2002)

Sample Windows Client in C++


We now include sample code for a simple Windows client (written in C++) so that those who wish to write a Windows client for QIS can examine it for reference. This code is supplied for your reference only and is not necessarily an optimum implementation; we will improve and enhance the example as we get more experience on both the server and client side.


Added API Command: Set_Image_Size


The client can now control the size of the bitmap image returned by the server. The client sends the Set_Image_Size command followed by the width and height of the bitmap in pixels.

Example


Set_Image_Size\n
512,512\n

For now, you cannot request a size that is greater than the image size of Qckvu when maximized on the screen of the machine that QIS is running on due to the method used to extract the image from the frame buffer. We plan to remove that limitation in a future release.


New API: Set_Image_Format (Windows Only)


This API command should only be used when both the server and client are running under Windows. The command instructs the server to return the display bitmap in the Windows GDI format instead of using GIF. Returning the GDI format is much more efficient since the client need not process the GIF in order to display it.

Example


Set_Image_Format\n
Bitmap8C\n  

            

this returns 8-bit Windows GDI using BI_RLE8 compression mode

If this mode is set, the image QIS returns will be in this format:

Image_Ready\n            - OR Get_Image (depending on what the client sent ...)
12345\n                  - the number of bytes to follow
BITMAPINFOHEADER         - the first 40 bytes will be BITMAPINFOHEADER
256 RGBQUAD Color Table  - the next 1024 bytes will be an array of 256
                           RGBQUAD
xxxxxxx                  - then the image bytes in BI_RLE8 compression
                           format

Use the header, the color table and the image directly in the GDI BITMAPINFO structure then use SetDIBits to create a GDI bitmap.  Refer to sample code for detail information.

In order to turn off the GDI mode and return to the default GIF mode use the API command:

Send Set_Image_Format\nGIF\n


Client Disconnect and Reconnect


With earlier versions of the server, if a client connected and exited, a new client might not be able to connect to the same server requiring that the server be stopped and restarted.  This has been fixed.