|
|
|
|
QisBool
Execution Control Functions |
|
|
|
|
|
|
|
|
|
|
Objective |
|
To
specify the amount of overlap between the butting polygons obtained by
converting leonov polygons to regular polygons. |
|
Prototype |
|
void
QisBoolOptions_SetOverlap( double iValue, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
double iValue: Specify the amount of overlap. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
The overlap amount (iValue) must be unitless. e.g If the file units is microns
(um) with a grid/resolution of 0.001 and the required overlap amount is
0.5um, then iValue = (0.5)/0.001 = 500. |
|
Operation |
|
a.
This function updates the internal state of the
QisBool object with the overlap value. b.
This overlap value will only be used if QisBoolOptions_SetLeonovOutput is set with mode
eLEONOV_OUT_BUTTING and the input polygon has holes (Leonov polygon). Both of these
functions must be called before the Boolean operation is executed. c.
To reset this feature, either use iValue = 0 or call QisBoolOptions_Reset. d.
This function as well as QisBoolOptions_SetLeonovOutput affects the
output of the following Boolean operation functions: |
|
|
|
Post-Conditions |
|
- |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetOverlap
( double iValue ) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
Force
QisBool to perform enhanced validation of polygons before performing Boolean
operations on them to avoid unexpected behavior/results. |
|
Prototype |
|
void
QisBoolOptions_SetEnhancedValidation( EOnOff iOnOff, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EOnOff iOnOff: eOFF or eON b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function must be called before QisBool_Booleanize, QisBool_UnionMT or QisBool_BinaryMT. b.
Default is eOFF |
|
Operation |
|
a.
This function sets a flag that forces maximum
validation of input polygons before they are processed for Boolean
operations. b.
Setting this feature ON will affect performance of the
Boolean operations. Therefore it must be used only when necessary. |
|
Post-Conditions |
|
a.
To reset this feature, call the function with eOFF or
call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetEnhancedValidation(EOnOff
iOnOff) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
treat a polygon that lies completely inside another polygon as a hole during
Boolean operations. |
|
Prototype |
|
void
QisBoolOptions_SetDeEmbedding( EOnOff iOnOff, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EOnOff iOnOff: eOFF or eON b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function must be called before QisBool_Booleanize. b.
Default is eOFF |
|
Operation |
|
a.
This function sets a flag that informs QisBool to
treat polygons that lie completely inside other polygons as holes and process
them appropriately. b.
If ON, the nature of the output will then depend on
the QisBoolOptions_SetLeonovOutput setting. c.
By default, (if this feature is OFF), the polygons
that lie completely inside other polygons will be discarded as being
redundant. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, call the function with eOFF or
call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetDeEmbedding(EOnOff
iOnOff) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
set the level of validation to be performed on the input polygons before
using them in Boolean operations. |
|
Prototype |
|
void
QisBoolOptions_SetValidationMode( EValidationMode iMode, void* iBoolHandle ); |
|
Input Arguments |
|
a.
EValidationMode iMode: eFULLY_VALIDATE
: Perform validation. (Default) eNO_SELF_INTR_CHK
: Perform validation without self intersection check (reduced validation). eNO_VALIDATION
: Do not perform validation. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function must be called before QisBool_Booleanize, QisBool_UnionMT or QisBool_BinaryMT. b.
Default is eFULLY_VALIDATE |
|
Operation |
|
a.
This function sets a flag that determines the degree
of validation of input polygons before executing Boolean operations. b.
This setting will affect the performance of Boolean
operations as follows: eFULLY_VALIDATE
: Fast eNO_SELF_INTR_CHK:
Faster eNO_VALIDATION:
Fastest |
|
Post-Conditions |
|
a.
To reset this feature, call the function with eFULLY_VALIDATE or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetValidationMode(EValidationMode
iMode) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
enable/disable union of data across stripes during QisBool_Booleanize. |
|
Prototype |
|
void
QisBoolOptions_SetPartUnion( EOnOff iOnOff, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EOnOff iOnOff: eON or eOFF (default) b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function must be called before QisBool_Booleanize. b.
This option works only for QisBool_Booleanize. c.
By default, the number of partitions is 1, therefore
this option does not apply even if enabled. |
|
Operation |
|
a.
If QisBoolOptions_SetPartition is set such that
number of partitions > 1, then this option determines if the data across
partitions will be unionized (eON) or not (eOFF). |
|
|
|
Post-Conditions |
|
a.
To reset this feature, call the function with eOFF or
call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetPartUnion( EOnOff iOnOff ) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
set the maximum number of vertices in output polygons generated by the
Boolean operations. |
|
Prototype |
|
void
QisBoolOptions_SetMaxPoints( int iMaxPoints, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
int iMaxPoints: Maximum number of vertices for output
polygons. (A rectangle has 5 vertices) b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function must be called before QisBool_Booleanize, QisBool_UnionMT or QisBool_BinaryMT. b.
By default, there is no limit on the number of
vertices in the output polygons (also if iMaxPoints is set to 0) |
|
Operation |
|
a.
This function can be used to control the number of
vertices in output polygons generated by the Boolean operation functions. |
|
Post-Conditions |
|
a.
To reset this feature, call the function with iMaxPoints
= 0 or call QisBoolOptions_Reset. b.
QisLib allows a maximum of 8190 vertices per polygon.
If the client wishes to use the output polygons with QisLib functions, this
function must be used to set the maximum number of vertices to <= 8190. |
|
|
|
C++ Equivalent |
|
virtual void
IQisBool:: SetMaxPoints( int iMaxPoints ) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
set a window for clipping polygons during Boolean operations. |
|
Prototype |
|
void
QisBoolOptions_SetClipWindow( int iMinX, int iMinY, int iMaxX, int iMaxY,
void* iBooleanHandle ); |
|
Input Arguments |
|
a.
int iMinX, int iMinY, int iMaxX, int iMaxY: lower left
and upper right co-ordinates of the clipping window. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function must be called before QisBool_Booleanize, QisBool_UnionMT or QisBool_BinaryMT. b.
The width (iMaxX - iMinX) and height (iMaxY - iMinY)
of the clipping window must be > 0. |
|
Operation |
|
a.
The clipping window set by this function will be used
during the Boolean operations. b.
The output polygons will be clipped against that
window. By default, the polygons generated by the Boolean operations will not
be clipped. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetClipWindow
( int iMinX, int iMinY, int iMaxX, int iMaxY ) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To specify
how the input data space will be partitioned during Boolean operations. |
|
Prototype |
|
void
QisBoolOptions_SetPartition( int iNClipX, int iNClipY, EPartitionModes
iMode, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
int iNClipX: Number of partitions in X. b.
int iNClipY: Number of partitions in Y. c.
EPartitionModes iMode: eBOOL_PART_MODE_NONE
: No partitioning. (default) eBOOL_PART_MODE_AUTO
: Auto partitioning. eBOOL_PART_MODE_MANUAL
: Manual partitioning using iNClipX and iNClipY. d.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
Sometimes when the input data set is large, it needs
to be partitioned spatially to avoid the 'N squared' problem and for
improving the efficiency of the computation. b.
This function can only be used with QisBool_Booleanize. QisBool_UnionMT and QisBool_BinaryMT always use auto partitioning
(eBOOL_PART_MODE_AUTO). c.
During auto partitioning, QisBool partitions the data
into horizontal stripes and determines the height of each stripe based on the
data density. |
|
Operation |
|
a.
If QisBoolOptions_SetPartUnion is ON, the output
data will be unionized regardless of the partitioning mode. (The partitions
will be removed). This applies to QisBool_Booleanize only. b.
If QisBoolOptions_SetPartUnion is OFF and
partitioning mode is not eBOOL_PART_MODE_NONE, the partitions will appear in
the output polygons (The output polygons will be clipped along partition
boundaries). This applies to QisBool_Booleanize only. c.
For QisBool_UnionMT and QisBool_BinaryMT, the polygons are
unionized (partitions are removed) regardless of the above settings. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, call this function with eBOOL_PART_MODE_NONE or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetPartition( int iNClipX, int iNClipY, EPartitionModes
iMode ) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
specify how to size the output
polygons during Boolean operations. |
|
Prototype |
|
void
QisBoolOptions_SetSizingMode(ESizingModes iMode, void* iBooleanHandle); |
|
Input Arguments |
|
a.
ESizingModes iMode: eNO_SIZING
: Do not size polygons. (default) eSTANDARD_SIZING
: Simplest form of sizing. This is fast but may result in illegal polygons.
This should be used only when the data is guaranteed to be simple (fully convex, manhattan) eISOTR_SIZING
: A more complex form of sizing which ensures that illegal polygons will not
be generated. However, the amount of sizing in X and Y is the same. This mode
can be used in conjunction with QisBoolOptions_SetRoundCorners for further
flavoring. eNONISOTR_SIZING
: Same as eISOTR_SIZING except that the amount of sizing in X and Y can be
different. This mode can be used in conjunction with QisBoolOptions_SetRoundCorners for further
flavoring. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
For eNONISOTR_SIZING the sizing parameters must be
specified using QisBoolOptions_SetNonIsotrSizing. c.
For eSTANDARD_SIZING or eISOTR_SIZING the sizing
parameters must be specified using QisBoolOptions_SetSizing. |
|
Operation |
|
a.
This function sets the mode which will be applied at
the end of the Boolean operations. b.
The sizing amount can be negative (shrinking) or
positive (expanding). |
|
|
|
Post-Conditions |
|
b.
To reset this feature, call this function with eNO_SIZING or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetSizingMode(ESizingModes
iMode) = 0; |
|
See Also |
|
QisBoolOptions_SetRoundCorners |
|
|
|
|
|
Objective |
|
To
specify the sizing value to be used with Standard Sizing and Isotropic sizing. |
|
Prototype |
|
void
QisBoolOptions_SetSizing(double iValue, void* iBooleanHandle); |
|
Input Arguments |
|
a.
double iValue: The amount of sizing to be applied in both
X and Y. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
The amount of sizing can be negative or positive. The
amount of sizing must be unitless. e.g If the file
units is microns (um) with a grid of 0.001 and the required sizing amount is
0.5um, then iValue = (0.5)/0.001 = 500. c.
This function must be used only if QisBoolOptions_SetSizingMode is set to
eSTANDARD_SIZING or eISOTR_SIZING. |
|
Operation |
|
a.
This function sets the amount of standard sizing that
will be applied at the end of the Boolean operations. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, call this function with iValue
= 0 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetSizing(double
iValue) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To smoothen
output polygon edges by removing edges that are smaller than the specified
threshold. (smoothing) |
|
Prototype |
|
void
QisBoolOptions_SetSmoothing(double iValue, void* iBooleanHandle); |
|
Input Arguments |
|
a.
double iValue: The minimum acceptable length of an
edge. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
The smoothing threshold must be unitless. e.g If the file units is microns
(um) with a grid of 0.001 and the smoothing threshold is 0.5um, then iValue =
(0.5)/0.001 = 500. |
|
Operation |
|
a.
This function sets the minimum length of edges in the
output polygons and takes effect after the Boolean operations. |
|
Post-Conditions |
|
a.
To reset this feature, use iValue = 0.0 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetSmoothing(double
iValue) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
remove polygons that are smaller/thinner than a certain size (sliver). |
|
Prototype |
|
void
QisBoolOptions_SetSliver(double iValue, void* iBooleanHandle); |
|
Input Arguments |
|
a.
double iValue: The threshold for acceptable polygon
size/thickness. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
The sliver value must be unitless. e.g If the file units is microns
(um) with a grid of 0.001 and the sliver value is 0.5um, then iValue =
(0.5)/0.001 = 500. |
|
Operation |
|
b.
This function removes an polygons from the output that
are smaller in size or thickness than the specified sliver value. |
|
Post-Conditions |
|
b.
To reset this feature, use iValue = 0.0 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetSliver(double
iValue) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To specify
a chord error for approximating
the arcs in round paths. |
|
Prototype |
|
void
QisBoolOptions_SetChordError(double iValue, void* iBooleanHandle); |
|
Input Arguments |
|
a.
double iValue: The maximum distance between a true arc
and it's approximating line segment. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
The chord error must be unitless. e.g If the file units is microns
(um) with a grid of 0.001 and the chord error is 0.5um, then iValue =
(0.5)/0.001 = 500. |
|
Operation |
|
a.
This function sets the chord error (arcsag) which will
be used to construct round paths. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, use iValue = 0.0 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetChordError(double
iValue) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
set the amount of sizing for non-isotropic sizing (mode eNONISOTR_SIZING for QisBoolOptions_SetSizingMode) |
|
Prototype |
|
void
QisBoolOptions_SetNonIsotrSizing ( double iSizeX, double iSizeY, void*
iBooleanHandle ); |
|
Input Arguments |
|
a.
double iSizeX, iSizeY: The amount of sizing to be
applied in X and Y respectively. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
The amount of sizing can be negative or positive. The
amount of sizing must be unitless. e.g If the file
units is microns (um) with a grid of 0.001 and the required sizing amount is
0.5um, then iValue = (0.5)/0.001 = 500. c.
This function must be used only if QisBoolOptions_SetSizingMode is set to eNONISOTR_SIZING. |
|
Operation |
|
a.
This function sets the amount of sizing in X and/or Y
that will be applied at the end of the Boolean operations. |
|
Post-Conditions |
|
a.
To reset this feature, call this function with iSizeX
= iSizeY = 0 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool::SetNonIsotrSizing(double iSizeX, double iSizeY) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
control how round corners are handled
during sizing when the sizing mode is set to
eISOTR_SIZING or eNONISOTR_SIZING. |
|
Prototype |
|
void
QisBoolOptions_SetRoundCorners( ERoundCorners iMode, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
ERoundCorners iMode: eRIGHT_ANGLE_CORNER
: To be used for manhattan data. eTHREE_POINT_CORNER
: Approximates a round corner as a set of three points equidistant from the
original corner. (default) eFIVE_POINT_CORNER
: Approximates a round corner as a set of five points equidistant from the
original corner. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
This function should be used when QisBoolOptions_SetSizingMode has been set to
eISOTR_SIZING or eNONISOTR_SIZING. |
|
Operation |
|
a.
This function sets the mode for handling round corners
and will take effect when the Boolean operations perform sizing. |
|
|
|
|
|
Post-Conditions |
|
a.
To reset this feature, set iMode = eTHREE_POINT_CORNER
or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetRoundCorners(ERoundCorners
iMode) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
control the number of vertices in a partition created during Boolean
operations when the partition mode is set to
eBOOL_PART_MODE_AUTO. |
|
Prototype |
|
void
QisBoolOptions_SetPartitioningThreshold ( int iNVertPerPartition, void*
iBooleanHandle ); |
|
Input Arguments |
|
a.
int iNVertPerPartition: Maximum number of vertices per
partition. (default 500,000) b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
This function should be used in conjunction with QisBoolOptions_SetPartition set to
eBOOL_PART_MODE_AUTO. |
|
Operation |
|
a.
This function sets the vertex count to determine how
to partition the data. It takes effect during the Boolean operations. b.
During auto-partitioning, the data is spatially
partitioned and clipped into stripes (horizontal partitions). The thickness
of each stripe can be controlled by this function. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, set iNVertPerPartition to
500,000 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool::SetPartitioningThreshold(int iNVertPerPartition) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To specify
which of the input polygon data sets have Leonov polygons. |
|
Prototype |
|
void
QisBoolOptions_SetLeonovInput ( ELeonovInput iMode, EOnOff iOnOff, void*
iBooleanHandle ); |
|
Input Arguments |
|
a.
ELeonovInput iMode: eLEONOV_OP_NONE
: None of the input polygons sets have Leonov data. (default) eLEONOV_OP_A
: Polygon set#1 has Leonov data. eLEONOV_OP_B
: Polygon set#2 has Leonov data. eLEONOV_OP_ALL
: Both polygons sets have Leonov data. b.
EOnOff iOnOff: If set to eOFF, iMode is ignored (same
as default). c.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
If either of the input polygon sets have Leonov data,
this function must be used appropriately. If not, then this function may not
be used. |
|
Operation |
|
a.
This function informs the Boolean operations that some
of the input polygons may be Leonov. Leonov polygons are represented as a
continuous set of multiple polygons representing the outer boundary and the
holes. It contains one polygon representing the outer boundary followed by
multiple polygons representing holes. For outer boundary, the number of
vertices is 'negative' and counter-clockwise. For holes, number of vertices
is positive and clockwise. b.
If either of the input sets contains Leonov polygons,
QisBool assumes that this data is already unionized. It will therefore avoid
unionizing them again. To force the Boolean operations to unionize the data
despite them being Leonov, use QisBoolOptions_SetForceUnion. c.
If this function is called more than once, it replaces
the previous setting. Hence, the effect of calling this function multiple
times is not cumulative. |
|
|
|
|
|
Post-Conditions |
|
b.
To reset this feature, set iMode = eLEONOV_OP_NONE or
iOnOff = eOFF or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetInputLeonov(ELeonovInput
iMode, EOnOff iOnOff) = 0; |
|
See Also |
|
|
|
|
||
|
Objective |
||
|
To
control how to output polygons with holes (Leonov polygons) |
||
|
Prototype |
||
|
void
QisBoolOptions_SetLeonovOutput ( ELeonovOutput iMode, void* iBooleanHandle ); |
||
|
Input Arguments |
||
|
a.
ELeonovOutput iMode: eLEONOV_OUT_STD
: Output Leonov polygons with cutlines. (default) eLEONOV_OUT_LEONOV
: Output Leonov polygons as Leonov. eLEONOV_OUT_BUTTING
: Output Leonov polygons with butting. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
||
|
Output Arguments |
||
|
- |
||
|
Return Value |
||
|
- |
||
|
Pre-Conditions |
||
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT, QisBool_BinaryMT. |
||
|
Operation |
||
|
a.
Leonov polygons are represented as a continuous set of
multiple polygons representing the outer boundary and the holes. It contains
one polygon representing the outer boundary followed by multiple polygons
representing holes. For outer boundary, the number of vertices is 'negative'.
For holes, number of vertices is positive. b.
Refer to this page for more
information about Leonov polygons and various output modes. |
||
|
|
|
|
|
Post-Conditions |
||
|
a.
To reset this feature, set iMode = eLEONOV_OUT_STD or
call QisBoolOptions_Reset. |
||
|
C++ Equivalent |
||
|
virtual void
IQisBool:: SetOutputLeonov(ELeonovOutput
iMode) = 0; |
||
|
See Also |
||
|
|
||
|
|
|
Objective |
|
To
control whether the output polygons must be tested for and made convex in X,
fully convex or trapezoids. |
|
Prototype |
|
void
QisBoolOptions_SetConvexOutput ( EConvexOutput iMode, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EConvexOutput iMode: eNO_CONVEX
: There is no guarantee that the output polygons will be convex (default). eCONVEX_IN_X
: The output polygons are guaranteed to be convex in X. eFULLY_CONVEX
: The output polygons are guaranteed to be convex in X and Y. eTRAPEZOIDS
: The output polygons are guaranteed to be trapezoids. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT, QisBool_BinaryMT. |
|
Operation |
|
a.
If this function is set in a mode other than
eNO_CONVEX, the output polygons are tested and converted according to the
specified convex mode during the Boolean operations. |
|
|
|
Post-Conditions |
|
a.
The option to output convex polygons does not work if
the QisBoolOptions_SetLeonovOutput is set to
eLEONOV_OUT_LEONOV. b.
To reset this feature, set iMode = eNO_CONVEX or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool::SetConvexOutput(EConvexOutput iMode) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To instruct
the QisBool_Booleanize to test is the
input data is manhattan. |
|
Prototype |
|
void
QisBoolOptions_SetTestManhattan( EManhFlag iMode, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EManhFlag iMode: eMANH_NOTEST
: Do not test for manhattan data in the input. (default) eMANH_TEST
: Test for manhattan data in the input. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create. |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used only with QisBool_Booleanize. b.
QisBool_Booleanize can take
advantage of some algorithmic adjustments that improves efficiency if it
knows that all of the input data is manhattan. |
|
Operation |
|
a.
QisBool_Booleanize will process
non-manhattan data regardless of this setting. However, enabling this check
helps optimize the boolean operation if the data is indeed manhattan. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, set iMode = eMANH_NOTEST or
call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetTestManhattan(EManhFlag
iMode) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
control the width/thickness of the lines returned by QisBool_GetSliceEdges. |
|
Prototype |
|
void
QisBoolOptions_SetEdgePtCompensation( int iValue, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
int iValue: The width/thickness (in database units) of
the lines returned by QisBool_GetSliceEdges. b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
In order to get the edges common to the butting polygons, QisBoolOptions_SetReturnSliceEdges must be set to eON
and the QisBoolOptions_SetLeonovOutput must be set to
eLEONOV_OUT_BUTTING. c.
The width must be unitless. e.g If the file units is microns
(um) with a grid of 0.001 and the width is 0.5um, then iValue = (0.5)/0.001 =
500. |
|
Operation |
|
a.
Compensates the coordinates returned by QisBool_GetSliceEdges to account for
the "width" of a so called patch line that a calling program will
use later to cover up any butting edges. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, set iValue = 0 or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool::SetEdgePtCompensation(int iValue) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
force the Boolean operations to unionize the input data even if it contains Leonov polygons. |
|
Prototype |
|
void
QisBoolOptions_SetForceUnion( EOnOff iOnOff, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EOnOff iOnOff: eON (ON) or eOFF(OFF) b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. |
|
Operation |
|
a.
If either of the input polygons sets contain Leonov
polygons (QisBoolOptions_SetLeonovInput), the Boolean
operations assume that the data has already been unionized and will avoid
unionizing them again. Using this function forces the Boolean operations to
unionize the input data. |
|
Post-Conditions |
|
b.
To reset this feature, set iOnOff = eOFF or call QisBoolOptions_Reset. |
|
C++ Equivalent |
|
virtual void
IQisBool:: SetForceUnion(EOnOff
iOnOff) = 0; |
|
See Also |
|
|
|
|
|
Objective |
|
To
instruct the Boolean operations to remember the edges used to generate butting polygons (slices) so that
it can be returned using QisBool_GetSliceEdges. |
|
Prototype |
|
void
QisBoolOptions_SetReturnSliceEdges( EOnOff iOnOff, void* iBooleanHandle ); |
|
Input Arguments |
|
a.
EOnOff iOnOff: eON (ON) or eOFF(OFF) b.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create |
|
Output Arguments |
|
- |
|
Return Value |
|
- |
|
Pre-Conditions |
|
a.
This function can be used with QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT. b.
In order to generate butting polygons, QisBoolOptions_SetLeonovOutput must be set to
eLEONOV_OUT_BUTTING. c.
In order to specify a width for these butting edges
(slices), use QisBoolOptions_SetEdgePtCompensation |
|
Operation |
|
a.
If this function is set (eON), the Boolean operations
remember the butting edges (slices) that generate the butting polygons. |
|
|
|
Post-Conditions |
|
a.
To reset this feature, set iOnOff = eOFF or call QisBoolOptions_Reset. b.
To get the butting edges, call QisBool_GetSliceEdges. |
|
C++ Equivalent |
|
virtual void
IQisBool::SetReturnSliceEdges(EOnOff iOnOff) = 0; |
|
See Also |
|
QisBoolOptions_SetLeonovOutput |
|
|
|
|
||
|
Objective |
||
|
Reset
QisBool settings. |
||
|
Prototype |
||
|
void
QisBoolOptions_Reset( void* iBooleanHandle ); |
||
|
Input Arguments |
||
|
a.
void* iBooleanHandle: Handle to a QisBool object
obtained using QisBool_Create |
||
|
Output Arguments |
||
|
- |
||
|
Return Value |
||
|
- |
||
|
Pre-Conditions |
||
|
- |
||
|
Operation |
||
|
a.
Resets the various QisBool execution control settings
that affect QisBool_Booleanize, QisBool_UnionMT and QisBool_BinaryMT to their
default values. |
||
|
Setting |
Function |
Default Value |
|
Overlap
between butting polygons |
0.0 |
|
|
Enable
DeEmbedding |
eOFF |
|
|
Enhanced
Validation |
eOFF |
|
|
Validation
Mode |
eFULLY_VALIDATE |
|
|
Force
Union for Leonov input |
eOFF |
|
|
Unionized
partitions |
eOFF |
|
|
Max.
Output vertices |
0
(Any) |
|
|
Clipping
window MinX,MinY to MaxX,MaxY |
-INT_MAX,-INT_MAX
to INT_MAX,INT_MAX |
|
|
Number
of partitions in X |
1 |
|
|
Number
of partitions in Y |
1 |
|
|
Partitioning
mode |
eBOOL_PART_MODE_NONE |
|
|
Auto-partition
threshold |
500,000 |
|
|
Sizing
Mode |
eNO_SIZING |
|
|
Standard
& Isotropic sizing |
0.0 |
|
|
Non
Isotropic sizing X,Y |
0.0,0.0 |
|
|
Smoothing
(Min. Edge size) |
0.0 |
|
|
Sliver
(Min. Polygon size) |
0.0 |
|
|
Chord
Error |
0.0 |
|
|
Get
butting edges |
eOFF |
|
|
Butting
edge compensation |
0.0 |
|
|
Round
Corners after sizing |
eTHREE_POINT_CORNER |
|
|
Leonov
Input |
eLEONOV_OP_NONE |
|
|
Leonov
Output |
eLEONOV_OUT_STD |
|
|
Convex
Output |
eNO_CONVEX |
|
|
Test
Manhattan input |
eMANH_NOTEST |
|
|
|
|
|
|
Post-Conditions |
||
|
- |
||
|
C++ Equivalent |
||
|
virtual void
IQisBool::ResetOptions() = 0; |
||
|
See Also |
||
|
|
||
|
|
|
|
© 2012 Artwork Conversion
Software Inc. |
|
|
417 Ingalls St. Santa Cruz CA
95060 |
|
|
[T] +1 831-426-6163 [F] +1
831-[E] info@artwork.com |
|