|
|
Class ShapeProcessor (version 0.18)Description: The shape processor (boolean, sizing, merge on shapes)
The shape processor implements the boolean and edge set operations (size, merge). Because the shape processor might allocate resources which can be reused in later operations, it is implemented as an object that can be used several times. The shape processor is similar to the EdgeProcessor. The latter is specialized on handling polygons and edges directly.
Class overview
Index
Method Overview
| merge( Layout layout, Cell cell, unsigned int layer, ref Shapes out, bool hierarchical, unsigned int min_wc, bool resolve_holes, bool min_coherence ) | Merge the given shapes from a layout into a shapes container |
| boolean( Layout layout_a, Cell cell_a, unsigned int layer_a, Layout layout_b, Cell cell_b, unsigned int layer_b, ref Shapes out, int mode, bool hierarchical, bool resolve_holes, bool min_coherence ) | Boolean operation on shapes from layouts |
| size( Layout layout, Cell cell, unsigned int layer, ref Shapes out, int dx, int dy, unsigned int mode, bool hierarchical, bool resolve_holes, bool min_coherence ) | Sizing operation on shapes from layouts |
| size( Layout layout, Cell cell, unsigned int layer, ref Shapes out, int d, unsigned int mode, bool hierarchical, bool resolve_holes, bool min_coherence ) | Sizing operation on shapes from layouts |
| Edge[ ] merge( Shape in[ ], CplxTrans trans[ ], unsigned int min_wc ) | Merge the given shapes |
| Polygon[ ] merge_to_polygon( Shape in[ ], CplxTrans trans[ ], unsigned int min_wc, bool resolve_holes, bool min_coherence ) | Merge the given shapes |
| Edge[ ] merge( Shape in[ ], unsigned int min_wc ) | Merge the given shapes |
| Polygon[ ] merge_to_polygon( Shape in[ ], unsigned int min_wc, bool resolve_holes, bool min_coherence ) | Merge the given shapes |
| Edge[ ] boolean( Shape in_a[ ], CplxTrans trans_a[ ], Shape in_b[ ], CplxTrans trans_b[ ], int mode ) | Boolean operation on two given shape sets into an edge set |
| Polygon[ ] boolean_to_polygon( Shape in_a[ ], CplxTrans trans_a[ ], Shape in_b[ ], CplxTrans trans_b[ ], int mode, bool resolve_holes, bool min_coherence ) | Boolean operation on two given shape sets into a polygon set |
| Edge[ ] boolean( Shape in_a[ ], Shape in_b[ ], int mode ) | Boolean operation on two given shape sets into an edge set |
| Polygon[ ] boolean_to_polygon( Shape in_a[ ], Shape in_b[ ], int mode, bool resolve_holes, bool min_coherence ) | Boolean operation on two given shape sets into a polygon set |
| Edge[ ] size( Shape in[ ], CplxTrans trans[ ], int d, unsigned int mode ) | Size the given shapes |
| Edge[ ] size( Shape in[ ], CplxTrans trans[ ], int dx, int dy, unsigned int mode ) | Size the given shapes |
| Polygon[ ] size_to_polygon( Shape in[ ], CplxTrans trans[ ], int d, unsigned int mode, bool resolve_holes, bool min_coherence ) | Size the given shapes |
| Polygon[ ] size_to_polygon( Shape in[ ], CplxTrans trans[ ], int dx, int dy, unsigned int mode, bool resolve_holes, bool min_coherence ) | Size the given shapes |
| Edge[ ] size( Shape in[ ], int d, unsigned int mode ) | Size the given shapes |
| Edge[ ] size( Shape in[ ], int dx, int dy, unsigned int mode ) | Size the given shapes |
| Polygon[ ] size_to_polygon( Shape in[ ], int d, unsigned int mode, bool resolve_holes, bool min_coherence ) | Size the given shapes |
| Polygon[ ] size_to_polygon( Shape in[ ], int dx, int dy, unsigned int mode, bool resolve_holes, bool min_coherence ) | Size the given shapes |
| assign( ShapeProcessor other ) | Assign the contents of another object to self |
| [const] ShapeProcessor dup | Creates a copy of self. |
| destroy | Explicitly destroy the object |
| [const] bool destroyed | Tell, if the object was destroyed |
Description: Assign the contents of another object to self This method assigns the contents of another object to self. This is a deep copy that does not only copy the reference but the actual content.
boolean( Layout layout_a, Cell cell_a, unsigned int layer_a, Layout layout_b, Cell cell_b, unsigned int layer_b, ref Shapes out, int mode, bool hierarchical, bool resolve_holes, bool min_coherence )
Description: Boolean operation on shapes from layouts
See the EdgeProcessor for a description of the boolean operations. This implementation takes shapes
from layout cells (optionally all in hierarchy) and produces new shapes in a shapes container.
| layout_a: | The layout from which to take the shapes for input A | | cell_a: | The cell (in 'layout') from which to take the shapes for input A | | layer_a: | The cell (in 'layout') from which to take the shapes for input A | | layout_b: | The layout from which to take the shapes for input B | | cell_b: | The cell (in 'layout') from which to take the shapes for input B | | layer_b: | The cell (in 'layout') from which to take the shapes for input B | | out: | The shapes container where to put the shapes into (is cleared before) | | mode: | The boolean operation (see EdgeProcessor) | | hierarchical: | Collect shapes from sub cells as well | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Edge[ ] boolean( Shape in_a[ ], CplxTrans trans_a[ ], Shape in_b[ ], CplxTrans trans_b[ ], int mode )
Description: Boolean operation on two given shape sets into an edge set
See the EdgeProcessor for a description of the boolean operations. This implementation takes shapes
rather than polygons for input and produces an edge set. | in_a: | The set of shapes to use for input A | | trans_a: | A set of transformations to apply before the shapes are used | | in_b: | The set of shapes to use for input A | | trans_b: | A set of transformations to apply before the shapes are used | | mode: | The boolean operation (see EdgeProcessor) |
Edge[ ] boolean( Shape in_a[ ], Shape in_b[ ], int mode )
Description: Boolean operation on two given shape sets into an edge set
See the EdgeProcessor for a description of the boolean operations. This implementation takes shapes
rather than polygons for input and produces an edge set. This version does not allow to specify a transformation for each shape (unity is assumed). | in_a: | The set of shapes to use for input A | | in_b: | The set of shapes to use for input A | | mode: | The boolean operation (see EdgeProcessor) |
Polygon[ ] boolean_to_polygon( Shape in_a[ ], Shape in_b[ ], int mode, bool resolve_holes, bool min_coherence )
Description: Boolean operation on two given shape sets into a polygon set
See the EdgeProcessor for a description of the boolean operations. This implementation takes shapes
rather than polygons for input and produces a polygon set. This version does not allow to specify a transformation for each shape (unity is assumed). | in_a: | The set of shapes to use for input A | | in_b: | The set of shapes to use for input A | | mode: | The boolean operation (see EdgeProcessor) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Polygon[ ] boolean_to_polygon( Shape in_a[ ], CplxTrans trans_a[ ], Shape in_b[ ], CplxTrans trans_b[ ], int mode, bool resolve_holes, bool min_coherence )
Description: Boolean operation on two given shape sets into a polygon set
See the EdgeProcessor for a description of the boolean operations. This implementation takes shapes
rather than polygons for input and produces a polygon set. | in_a: | The set of shapes to use for input A | | trans_a: | A set of transformations to apply before the shapes are used | | in_b: | The set of shapes to use for input A | | trans_b: | A set of transformations to apply before the shapes are used | | mode: | The boolean operation (see EdgeProcessor) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Description: Explicitly destroy the object Explicitly destroy the object on C++ side if it was owned by the Ruby interpreter. Subsequent access to this object will throw an exception.
If the object is not owned by Ruby, this method will do nothing.
Description: Tell, if the object was destroyed This method returns true, if the object was destroyed, either explicitly or by the C++ side.
The latter may happen, if the object is owned by a C++ object which got destroyed itself.
Description: Creates a copy of self.
Edge[ ] merge( Shape in[ ], unsigned int min_wc )
Description: Merge the given shapes
See the EdgeProcessor for a description of the merge method. This implementation takes shapes
rather than polygons for input and produces an edge set. This version does not allow to specify a transformation for each shape (unity is assumed). | in: | The set of shapes to merge | | min_wc: | The minimum wrap count for output (0: all polygons, 1: at least two overlapping) |
Edge[ ] merge( Shape in[ ], CplxTrans trans[ ], unsigned int min_wc )
Description: Merge the given shapes
See the EdgeProcessor for a description of the merge method. This implementation takes shapes
rather than polygons for input and produces an edge set. | in: | The set of shapes to merge | | trans: | A corresponding set of transformations to apply on the shapes | | min_wc: | The minimum wrap count for output (0: all polygons, 1: at least two overlapping) |
merge( Layout layout, Cell cell, unsigned int layer, ref Shapes out, bool hierarchical, unsigned int min_wc, bool resolve_holes, bool min_coherence )
Description: Merge the given shapes from a layout into a shapes container
See the EdgeProcessor for a description of the merge method. This implementation takes shapes
from a layout cell (optionally all in hierarchy) and produces new shapes in a shapes container.
| layout: | The layout from which to take the shapes | | cell: | The cell (in 'layout') from which to take the shapes | | layer: | The cell (in 'layout') from which to take the shapes | | out: | The shapes container where to put the shapes into (is cleared before) | | hierarchical: | Collect shapes from sub cells as well | | min_wc: | The minimum wrap count for output (0: all polygons, 1: at least two overlapping) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Polygon[ ] merge_to_polygon( Shape in[ ], unsigned int min_wc, bool resolve_holes, bool min_coherence )
Description: Merge the given shapes
See the EdgeProcessor for a description of the merge method. This implementation takes shapes
rather than polygons for input and produces a polygon set. This version does not allow to specify a transformation for each shape (unity is assumed). | in: | The set of shapes to merge | | min_wc: | The minimum wrap count for output (0: all polygons, 1: at least two overlapping) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Polygon[ ] merge_to_polygon( Shape in[ ], CplxTrans trans[ ], unsigned int min_wc, bool resolve_holes, bool min_coherence )
Description: Merge the given shapes
See the EdgeProcessor for a description of the merge method. This implementation takes shapes
rather than polygons for input and produces a polygon set. | in: | The set of shapes to merge | | trans: | A corresponding set of transformations to apply on the shapes | | min_wc: | The minimum wrap count for output (0: all polygons, 1: at least two overlapping) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
size( Layout layout, Cell cell, unsigned int layer, ref Shapes out, int dx, int dy, unsigned int mode, bool hierarchical, bool resolve_holes, bool min_coherence )
Description: Sizing operation on shapes from layouts
See the EdgeProcessor for a description of the sizing operation. This implementation takes shapes
from a layout cell (optionally all in hierarchy) and produces new shapes in a shapes container.
| layout: | The layout from which to take the shapes | | cell: | The cell (in 'layout') from which to take the shapes | | layer: | The cell (in 'layout') from which to take the shapes | | out: | The shapes container where to put the shapes into (is cleared before) | | dx: | The sizing value in x-direction (see EdgeProcessor) | | dy: | The sizing value in y-direction (see EdgeProcessor) | | mode: | The sizing mode (see EdgeProcessor) | | hierarchical: | Collect shapes from sub cells as well | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Edge[ ] size( Shape in[ ], CplxTrans trans[ ], int dx, int dy, unsigned int mode )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces an edge set. | in: | The set of shapes to size | | trans: | A corresponding set of transformations to apply on the shapes | | dx: | The sizing value in x-direction | | dy: | The sizing value in y-direction | | mode: | The sizing mode (see EdgeProcessor) |
Edge[ ] size( Shape in[ ], int d, unsigned int mode )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces an edge set. This is isotropic version that does not allow
to specify different values in x and y direction.
This version does not allow to specify a transformation for each shape (unity is assumed). | in: | The set of shapes to size | | d: | The sizing value | | mode: | The sizing mode (see EdgeProcessor) |
Edge[ ] size( Shape in[ ], int dx, int dy, unsigned int mode )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces an edge set. This version does not allow to specify a transformation for each shape (unity is assumed). | in: | The set of shapes to size | | dx: | The sizing value in x-direction | | dy: | The sizing value in y-direction | | mode: | The sizing mode (see EdgeProcessor) |
size( Layout layout, Cell cell, unsigned int layer, ref Shapes out, int d, unsigned int mode, bool hierarchical, bool resolve_holes, bool min_coherence )
Description: Sizing operation on shapes from layouts
See the EdgeProcessor for a description of the sizing operation. This implementation takes shapes
from a layout cell (optionally all in hierarchy) and produces new shapes in a shapes container. This is the isotropic version which does not allow to specify different sizing values in x and y-direction.
| layout: | The layout from which to take the shapes | | cell: | The cell (in 'layout') from which to take the shapes | | layer: | The cell (in 'layout') from which to take the shapes | | out: | The shapes container where to put the shapes into (is cleared before) | | d: | The sizing value (see EdgeProcessor) | | mode: | The sizing mode (see EdgeProcessor) | | hierarchical: | Collect shapes from sub cells as well | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Edge[ ] size( Shape in[ ], CplxTrans trans[ ], int d, unsigned int mode )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces an edge set. This is isotropic version that does not allow
to specify different values in x and y direction.
| in: | The set of shapes to size | | trans: | A corresponding set of transformations to apply on the shapes | | d: | The sizing value | | mode: | The sizing mode (see EdgeProcessor) |
Polygon[ ] size_to_polygon( Shape in[ ], int dx, int dy, unsigned int mode, bool resolve_holes, bool min_coherence )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces a polygon set. This version does not allow to specify a transformation for each shape (unity is assumed). | in: | The set of shapes to size | | dx: | The sizing value in x-direction | | dy: | The sizing value in y-direction | | mode: | The sizing mode (see EdgeProcessor) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Polygon[ ] size_to_polygon( Shape in[ ], CplxTrans trans[ ], int dx, int dy, unsigned int mode, bool resolve_holes, bool min_coherence )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces a polygon set. | in: | The set of shapes to size | | trans: | A corresponding set of transformations to apply on the shapes | | dx: | The sizing value in x-direction | | dy: | The sizing value in y-direction | | mode: | The sizing mode (see EdgeProcessor) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Polygon[ ] size_to_polygon( Shape in[ ], CplxTrans trans[ ], int d, unsigned int mode, bool resolve_holes, bool min_coherence )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces a polygon set. This is isotropic version that does not allow
to specify different values in x and y direction.
| in: | The set of shapes to size | | trans: | A corresponding set of transformations to apply on the shapes | | d: | The sizing value | | mode: | The sizing mode (see EdgeProcessor) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
Polygon[ ] size_to_polygon( Shape in[ ], int d, unsigned int mode, bool resolve_holes, bool min_coherence )
Description: Size the given shapes
See the EdgeProcessor for a description of the sizing method. This implementation takes shapes
rather than polygons for input and produces a polygon set. This is isotropic version that does not allow
to specify different values in x and y direction.
This version does not allow to specify a transformation for each shape (unity is assumed). | in: | The set of shapes to size | | d: | The sizing value | | mode: | The sizing mode (see EdgeProcessor) | | resolve_holes: | true, if holes should be resolved into the hull | | min_coherence: | true, if minimum polygons should be created for touching corners |
|