Main API¶
gdspy is a Python module that allows the creation of GDSII stream files.
Many features of the GDSII format are implemented, such as cell references and arrays, but the support for fonts is quite limited. Text is only available through polygonal objects.
If the Python Imaging Library is installed, it can be used to output the geometry created to an image file.
Classes¶
Cell¶
-
class
gdspy.
Cell
(name, exclude_from_global=False)¶ Bases:
object
Collection of elements, both geometric objects and references to other cells.
Parameters: name : string
The name of the cell.
exclude_from_global : bool
If
True
, the cell will not be included in the global list of cells maintained bygdspy
.Methods
-
add
(element)¶ Add a new element or list of elements to this cell.
Parameters: element : object, list
The element or list of elements to be inserted in this cell.
Returns: out :
Cell
This cell.
-
area
(by_spec=False)¶ Calculate the total area of the elements on this cell, including cell references and arrays.
Parameters: by_spec : bool
If
True
, the return value is a dictionary with the areas of each individual pair (layer, datatype).Returns: out : number, dictionary
Area of this cell.
-
cell_dict
= {}¶ Dictionary containing all cells created, indexed by name. This dictionary is updated automatically whenever a new
Cell
object is created without theexclude_from_global
flag.
-
copy
(name, exclude_from_global=False, deep_copy=False)¶ Creates a copy of this cell.
Parameters: name : string
The name of the cell.
exclude_from_global : bool
If
True
, the cell will not be included in the global list of cells maintained bygdspy
.deep_copy : bool
If
False
, the new cell will contain only references to the existing elements. IfTrue
, copies of all elements are also created.Returns: out :
Cell
The new copy of this cell.
-
flatten
(single_layer=None, single_datatype=None, verbose=True)¶ Flatten all
CellReference
andCellArray
elements in this cell into real polygons, instead of references.Parameters: single_layer : integer or None
If not
None
, all polygons will be transfered to the layer indicated by this number.single_datatype : integer or None
If not
None
, all polygons will be transfered to the datatype indicated by this number.verbose : bool
If False, warnings about the number of vertices of the polygon will be suppressed.
Returns: out :
Cell
This cell.
-
get_bounding_box
()¶ Returns the bounding box for this cell.
Returns: out : Numpy array[2,2] or
None
Bounding box of this cell [[x_min, y_min], [x_max, y_max]], or
None
if the cell is empty.
-
get_datatypes
()¶ Returns a list of datatypes in this cell.
Returns: out : list
List of the datatypes used in this cell.
-
get_dependencies
()¶ Returns a list of the cells included in this cell as references.
Returns: out : list of
Cell
List of the cells referenced by this cell.
-
get_layers
()¶ Returns a list of layers in this cell.
Returns: out : list
List of the layers used in this cell.
-
get_polygons
(by_spec=False, depth=None)¶ Returns a list of polygons in this cell.
Parameters: by_spec : bool
If
True
, the return value is a dictionary with the polygons of each individual pair (layer, datatype).depth : integer or
None
If not
None
, defines from how many reference levels to retrieve polygons. References below this level will result in a bounding box. Ifby_spec
isTrue
the key wil be the name of this cell.Returns: out : list of array-like[N][2] or dictionary
List containing the coordinates of the vertices of each polygon, or dictionary with the list of polygons (if
by_spec
isTrue
).
-
to_gds
(multiplier)¶ Convert this cell to a GDSII structure.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII structure.
Returns: out : string
The GDSII binary string that represents this cell.
-
Polygon¶
-
class
gdspy.
Polygon
(points, layer=0, datatype=0, verbose=True)¶ Bases:
object
Polygonal geometric object.
Parameters: points : array-like[N][2]
Coordinates of the vertices of the polygon.
layer : integer
The GDSII layer number for this element.
datatype : integer
The GDSII datatype for this element (between 0 and 255).
verbose : bool
If False, warnings about the number of vertices of the polygon will be suppressed.
Notes
The last point should not be equal to the first (polygons are automatically closed).
The GDSII specification supports only a maximum of 199 vertices per polygon.
Examples
>>> triangle_pts = [(0, 40), (15, 40), (10, 50)] >>> triangle = gdspy.Polygon(triangle_pts) >>> myCell.add(triangle)
Methods
-
area
(by_spec=False)¶ Calculate the total area of this object.
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of this polygon and fractures it into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners.
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
Polygon
orPolygonSet
If no fracturing occurs, return this object; otherwise return a
PolygonSet
with the fractured result (this object will have more thanmax_points
vertices).
-
fracture
(max_points=199)¶ Slice this polygon in the horizontal and vertical directions so that each resulting piece has at most
max_points
.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
Resulting polygons from the fracture operation.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
Polygon
This object.
-
to_gds
(multiplier)¶ Convert this object to a GDSII element.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII element.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygon from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
Polygon
This object.
Examples
>>> polygon = gdspy.Polygon((0, 0), (10, 20)) >>> polygon = polygon.translate(2,0) >>> myCell.add(polygon)
-
Rectangle¶
-
class
gdspy.
Rectangle
(point1, point2, layer=0, datatype=0)¶ Bases:
gdspy.Polygon
Rectangular geometric object.
Parameters: point1 : array-like[2]
Coordinates of a corner of the rectangle.
point2 : array-like[2]
Coordinates of the corner of the rectangle opposite to
point1
.layer : integer
The GDSII layer number for this element.
datatype : integer
The GDSII datatype for this element (between 0 and 255).
Examples
>>> rectangle = gdspy.Rectangle((0, 0), (10, 20)) >>> myCell.add(rectangle)
Methods
-
area
(by_spec=False)¶ Calculate the total area of this object.
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of this polygon and fractures it into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners.
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
Polygon
orPolygonSet
If no fracturing occurs, return this object; otherwise return a
PolygonSet
with the fractured result (this object will have more thanmax_points
vertices).
-
fracture
(max_points=199)¶ Slice this polygon in the horizontal and vertical directions so that each resulting piece has at most
max_points
.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
Resulting polygons from the fracture operation.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
Polygon
This object.
-
to_gds
(multiplier)¶ Convert this object to a GDSII element.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII element.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygon from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
Polygon
This object.
Examples
>>> polygon = gdspy.Polygon((0, 0), (10, 20)) >>> polygon = polygon.translate(2,0) >>> myCell.add(polygon)
-
Round¶
-
class
gdspy.
Round
(center, radius, inner_radius=0, initial_angle=0, final_angle=0, number_of_points=0.01, max_points=199, layer=0, datatype=0)¶ Bases:
gdspy.PolygonSet
Circular geometric object. Represent a circle, a circular section, a ring or a ring section.
Parameters: center : array-like[2]
Coordinates of the center of the circle/ring.
radius : number
Radius of the circle/outer radius of the ring.
inner_radius : number
Inner radius of the ring.
initial_angle : number
Initial angle of the circular/ring section (in radians).
final_angle : number
Final angle of the circular/ring section (in radians).
number_of_points : integer or float
If integer: number of vertices that form the object (polygonal approximation). If float: approximate curvature resolution. The actual number of points is automatically calculated.
max_points : integer
if
number_of_points > max_points
, the element will be fractured in smaller polygons with at mostmax_points
each.layer : integer
The GDSII layer number for this element.
datatype : integer
The GDSII datatype for this element (between 0 and 255).
Notes
The GDSII specification supports only a maximum of 199 vertices per polygon.
Examples
>>> circle = gdspy.Round((30, 5), 8) >>> ring = gdspy.Round((50, 5), 8, inner_radius=5) >>> pie_slice = gdspy.Round((30, 25), 8, initial_angle=0, ... final_angle=-5.0*numpy.pi/6.0) >>> arc = gdspy.Round((50, 25), 8, inner_radius=5, ... initial_angle=-5.0*numpy.pi/6.0, ... final_angle=0)
Methods
-
area
(by_spec=False)¶ Calculate the total area of the path(s).
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of these polygons and fractures them into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners. If number: All corners filleted by that amount If list: Specify fillet radii on a per-corner basis (list length must be equal to the number of points in the Polygon)
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
fracture
(max_points=199)¶ Slice these polygons in the horizontal and vertical directions so that each resulting piece has at most
max_points
. This operation occurs in place.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
PolygonSet
This object.
-
to_gds
(multiplier)¶ Convert this object to a series of GDSII elements.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII elements.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygons from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
PolygonSet
This object.
-
PolygonSet¶
-
class
gdspy.
PolygonSet
(polygons, layer=0, datatype=0, verbose=True)¶ Bases:
object
Set of polygonal objects.
Parameters: polygons : list of array-like[N][2]
List containing the coordinates of the vertices of each polygon.
layer : integer
The GDSII layer number for this element.
datatype : integer
The GDSII datatype for this element (between 0 and 255).
verbose : bool
If False, warnings about the number of vertices of the polygons will be suppressed.
Notes
The last point should not be equal to the first (polygons are automatically closed).
The GDSII specification supports only a maximum of 199 vertices per polygon.
Methods
-
area
(by_spec=False)¶ Calculate the total area of the path(s).
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of these polygons and fractures them into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners. If number: All corners filleted by that amount If list: Specify fillet radii on a per-corner basis (list length must be equal to the number of points in the Polygon)
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
fracture
(max_points=199)¶ Slice these polygons in the horizontal and vertical directions so that each resulting piece has at most
max_points
. This operation occurs in place.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
PolygonSet
This object.
-
to_gds
(multiplier)¶ Convert this object to a series of GDSII elements.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII elements.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygons from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
PolygonSet
This object.
-
Path¶
-
class
gdspy.
Path
(width, initial_point=(0, 0), number_of_paths=1, distance=0)¶ Bases:
gdspy.PolygonSet
Series of geometric objects that form a path or a collection of parallel paths.
Parameters: width : number
The width of each path.
initial_point : array-like[2]
Starting position of the path.
number_of_paths : positive integer
Number of parallel paths to create simultaneously.
distance : number
Distance between the centers of adjacent paths.
Attributes
x (number) Current position of the path in the x direction. y (number) Current position of the path in the y direction. w (number) Half-width of each path. n (integer) Number of parallel paths. direction ({‘+x’, ‘-x’, ‘+y’, ‘-y’} or number) Direction or angle (in radians) the path points to. distance (number) Distance between the centers of adjacent paths. length (number) Length of the central path axis. If only one path is created, this is the real length of the path. Methods
-
arc
(radius, initial_angle, final_angle, number_of_points=0.01, max_points=199, final_width=None, final_distance=None, layer=0, datatype=0)¶ Add a curved section to the path.
Parameters: radius : number
Central radius of the section.
initial_angle : number
Initial angle of the curve (in radians).
final_angle : number
Final angle of the curve (in radians).
number_of_points : integer or float
If integer: number of vertices that form the object (polygonal approximation). If float: approximate curvature resolution. The actual number of points is automatically calculated.
max_points : integer
if
number_of_points > max_points
, the element will be fractured in smaller polygons with at mostmax_points
each.final_width : number
If set, the paths of this segment will have their widths linearly changed from their current value to this one.
final_distance : number
If set, the distance between paths is linearly change from its current value to this one along this segment.
layer : integer, list
The GDSII layer numbers for the elements of each path. If the number of layers in the list is less than the number of paths, the list is repeated.
datatype : integer, list
The GDSII datatype for the elements of each path (between 0 and 255). If the number of datatypes in the list is less than the number of paths, the list is repeated.
Returns: out :
Path
This object.
Notes
The GDSII specification supports only a maximum of 199 vertices per polygon.
-
area
(by_spec=False)¶ Calculate the total area of the path(s).
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of these polygons and fractures them into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners. If number: All corners filleted by that amount If list: Specify fillet radii on a per-corner basis (list length must be equal to the number of points in the Polygon)
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
fracture
(max_points=199)¶ Slice these polygons in the horizontal and vertical directions so that each resulting piece has at most
max_points
. This operation occurs in place.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
parametric
(curve_function, curve_derivative=None, number_of_evaluations=99, max_points=199, final_width=None, final_distance=None, layer=0, datatype=0)¶ Add a parametric curve to the path.
Parameters: curve_function : function
Function that defines the curve. Must be a function of one argument (that varies from 0 to 1) that returns a 2-element list, tuple or array (x, y).
curve_derivative : function
If set, it should be the derivative of the curve function. Must be a function of one argument (that varies from 0 to 1) that returns a 2-element list, tuple or array (x,y). If
None
, the derivative will be calculated numerically.number_of_evaluations : integer
Number of points where the curve function will be evaluated. The final segment will have twice this number of points.
max_points : integer
If
2 * number_of_evaluations > max_points
, the element will be fractured in smaller polygons with at mostmax_points
each.final_width : number or function
If set to a number, the paths of this segment will have their widths linearly changed from their current value to this one. If set to a function, it must be a function of one argument (that varies from 0 to 1) and returns the width of the path.
final_distance : number or function
If set to ta number, the distance between paths is linearly change from its current value to this one. If set to a function, it must be a function of one argument (that varies from 0 to 1) and returns the width of the path.
layer : integer, list
The GDSII layer numbers for the elements of each path. If the number of layers in the list is less than the number of paths, the list is repeated.
datatype : integer, list
The GDSII datatype for the elements of each path (between 0 and 255). If the number of datatypes in the list is less than the number of paths, the list is repeated.
Returns: out :
Path
This object.
Notes
The norm of the vector returned by
curve_derivative
is not important. Only the direction is used.The GDSII specification supports only a maximum of 199 vertices per polygon.
Examples
>>> def my_parametric_curve(t): ... return (2**t, t**2) >>> def my_parametric_curve_derivative(t): ... return (0.69315 * 2**t, 2 * t) >>> my_path.parametric(my_parametric_curve, ... my_parametric_curve_derivative)
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
Path
This object.
-
segment
(length, direction=None, final_width=None, final_distance=None, axis_offset=0, layer=0, datatype=0)¶ Add a straight section to the path.
Parameters: length : number
Length of the section to add.
direction : {‘+x’, ‘-x’, ‘+y’, ‘-y’} or number
Direction or angle (in radians) of rotation of the segment.
final_width : number
If set, the paths of this segment will have their widths linearly changed from their current value to this one.
final_distance : number
If set, the distance between paths is linearly change from its current value to this one along this segment.
axis_offset : number
If set, the paths will be offset from their direction by this amount.
layer : integer, list
The GDSII layer numbers for the elements of each path. If the number of layers in the list is less than the number of paths, the list is repeated.
datatype : integer, list
The GDSII datatype for the elements of each path (between 0 and 255). If the number of datatypes in the list is less than the number of paths, the list is repeated.
Returns: out :
Path
This object.
-
to_gds
(multiplier)¶ Convert this object to a series of GDSII elements.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII elements.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygons from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
PolygonSet
This object.
-
turn
(radius, angle, number_of_points=0.01, max_points=199, final_width=None, final_distance=None, layer=0, datatype=0)¶ Add a curved section to the path.
Parameters: radius : number
Central radius of the section.
angle : {‘r’, ‘l’, ‘rr’, ‘ll’} or number
Angle (in radians) of rotation of the path. The values ‘r’ and ‘l’ represent 90-degree turns cw and ccw, respectively; the values ‘rr’ and ‘ll’ represent analogous 180-degree turns.
number_of_points : integer or float
If integer: number of vertices that form the object (polygonal approximation). If float: approximate curvature resolution. The actual number of points is automatically calculated.
max_points : integer
if
number_of_points > max_points
, the element will be fractured in smaller polygons with at mostmax_points
each.final_width : number
If set, the paths of this segment will have their widths linearly changed from their current value to this one.
final_distance : number
If set, the distance between paths is linearly change from its current value to this one along this segment.
layer : integer, list
The GDSII layer numbers for the elements of each path. If the number of layers in the list is less than the number of paths, the list is repeated.
datatype : integer, list
The GDSII datatype for the elements of each path (between 0 and 255). If the number of datatypes in the list is less than the number of paths, the list is repeated.
Returns: out :
Path
This object.
Notes
The GDSII specification supports only a maximum of 199 vertices per polygon.
-
PolyPath¶
-
class
gdspy.
PolyPath
(points, width, number_of_paths=1, distance=0, corners=0, ends=0, max_points=199, layer=0, datatype=0)¶ Bases:
gdspy.PolygonSet
Series of geometric objects that form a polygonal path or a collection of parallel polygonal paths.
Parameters: points : array-like[N][2]
Endpoints of each path segment.
width : number or array-like[N]
Width of the path. If an array is given, width at each endpoint.
number_of_paths : positive integer
Number of parallel paths to create simultaneously.
distance : number or array-like[N]
Distance between the centers of adjacent paths. If an array is given, distance at each endpoint.
corners : positive integer
Type of joins: 0 - miter join, 1 - bevel join
ends : positive integer
Type of path ends: 0 - no extension, 1 - rounded, 2 - extended by half width
max_points : integer
The paths will be fractured in polygons with at most
max_points
.layer : integer, list
The GDSII layer numbers for the elements of each path. If the number of layers in the list is less than the number of paths, the list is repeated.
datatype : integer, list
The GDSII datatype for the elements of each path (between 0 and 255). If the number of datatypes in the list is less than the number of paths, the list is repeated.
Returns: out :
PolyPath
This object.
Notes
The bevel join will give strange results if the number of paths is greater than 1.
Methods
-
area
(by_spec=False)¶ Calculate the total area of the path(s).
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of these polygons and fractures them into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners. If number: All corners filleted by that amount If list: Specify fillet radii on a per-corner basis (list length must be equal to the number of points in the Polygon)
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
fracture
(max_points=199)¶ Slice these polygons in the horizontal and vertical directions so that each resulting piece has at most
max_points
. This operation occurs in place.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
PolygonSet
This object.
-
to_gds
(multiplier)¶ Convert this object to a series of GDSII elements.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII elements.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygons from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
PolygonSet
This object.
-
L1Path¶
-
class
gdspy.
L1Path
(initial_point, direction, width, length, turn, number_of_paths=1, distance=0, max_points=199, layer=0, datatype=0)¶ Bases:
gdspy.PolygonSet
Series of geometric objects that form a path or a collection of parallel paths with Manhattan geometry.
Parameters: initial_point : array-like[2]
Starting position of the path.
direction : {‘+x’, ‘+y’, ‘-x’, ‘-y’}
Starting direction of the path.
width : number
The initial width of each path.
length : array-like
Lengths of each section to add.
turn : array-like
Direction to turn before each section. The sign indicate the turn direction (ccw is positive), and the modulus is a multiplicative factor for the path width after each turn. Must have 1 element less then
length
.number_of_paths : positive integer
Number of parallel paths to create simultaneously.
distance : number
Distance between the centers of adjacent paths.
layer : integer, list
The GDSII layer numbers for the elements of each path. If the number of layers in the list is less than the number of paths, the list is repeated.
datatype : integer, list
The GDSII datatype for the elements of each path (between 0 and 255). If the number of datatypes in the list is less than the number of paths, the list is repeated.
Returns: out :
L1Path
This object.
Examples
>>> length = [10, 30, 15, 15, 15, 15, 10] >>> turn = [1, -1, -1, 3, -1, 1] >>> l1path = gdspy.L1Path((0, 0), '+x', 2, length, turn) >>> myCell.add(l1path)
Attributes
x (number) Final position of the path in the x direction. y (number) Final position of the path in the y direction. direction ({‘+x’, ‘-x’, ‘+y’, ‘-y’} or number) Direction or angle (in radians) the path points to. The numerical angle is returned only after a rotation of the object. Methods
-
area
(by_spec=False)¶ Calculate the total area of the path(s).
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of these polygons and fractures them into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners. If number: All corners filleted by that amount If list: Specify fillet radii on a per-corner basis (list length must be equal to the number of points in the Polygon)
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
fracture
(max_points=199)¶ Slice these polygons in the horizontal and vertical directions so that each resulting piece has at most
max_points
. This operation occurs in place.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
L1Path
This object.
-
to_gds
(multiplier)¶ Convert this object to a series of GDSII elements.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII elements.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygons from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
PolygonSet
This object.
-
Text¶
-
class
gdspy.
Text
(text, size, position=(0, 0), horizontal=True, angle=0, layer=0, datatype=0)¶ Bases:
gdspy.PolygonSet
Polygonal text object.
Each letter is formed by a series of polygons.
Parameters: text : string
The text to be converted in geometric objects.
size : number
Base size of each character.
position : array-like[2]
Text position (lower left corner).
horizontal : bool
If
True
, the text is written from left to right; ifFalse
, from top to bottom.angle : number
The angle of rotation of the text.
layer : integer
The GDSII layer number for these elements.
datatype : integer
The GDSII datatype for this element (between 0 and 255).
Examples
>>> text = gdspy.Text('Sample text', 20, (-10, -100)) >>> myCell.add(text)
Methods
-
area
(by_spec=False)¶ Calculate the total area of the path(s).
Parameters: by_spec : bool
If
True
, the return value is a dictionary{(layer, datatype): area}
.Returns: out : number, dictionary
Area of this object.
-
fillet
(radius, points_per_2pi=128, max_points=199)¶ Round the corners of these polygons and fractures them into polygons with less vertices if necessary.
Parameters: radius : number, list
Radius of the corners. If number: All corners filleted by that amount If list: Specify fillet radii on a per-corner basis (list length must be equal to the number of points in the Polygon)
points_per_2pi : integer
Number of vertices used to approximate a full circle. The number of vertices in each corner of the polygon will be the fraction of this number corresponding to the angle encompassed by that corner with respect to 2 pi.
max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
fracture
(max_points=199)¶ Slice these polygons in the horizontal and vertical directions so that each resulting piece has at most
max_points
. This operation occurs in place.Parameters: max_points : integer
Maximal number of points in each resulting polygon (must be greater than 4).
Returns: out :
PolygonSet
This object.
-
rotate
(angle, center=(0, 0))¶ Rotate this object.
Parameters: angle : number
The angle of rotation (in radians).
center : array-like[2]
Center point for the rotation.
Returns: out :
PolygonSet
This object.
-
to_gds
(multiplier)¶ Convert this object to a series of GDSII elements.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII elements.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the polygons from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
PolygonSet
This object.
-
CellReference¶
-
class
gdspy.
CellReference
(ref_cell, origin=(0, 0), rotation=None, magnification=None, x_reflection=False)¶ Bases:
object
Simple reference to an existing cell.
Parameters: ref_cell :
Cell
or stringThe referenced cell or its name.
origin : array-like[2]
Position where the reference is inserted.
rotation : number
Angle of rotation of the reference (in degrees).
magnification : number
Magnification factor for the reference.
x_reflection : bool
If
True
, the reference is reflected parallel to the x direction before being rotated.Methods
-
area
(by_spec=False)¶ Calculate the total area of the referenced cell with the magnification factor included.
Parameters: by_spec : bool
If
True
, the return value is a dictionary with the areas of each individual pair (layer, datatype).Returns: out : number, dictionary
Area of this cell.
-
get_bounding_box
()¶ Returns the bounding box for this reference.
Returns: out : Numpy array[2,2] or
None
Bounding box of this cell [[x_min, y_min], [x_max, y_max]], or
None
if the cell is empty.
-
get_polygons
(by_spec=False, depth=None)¶ Returns a list of polygons created by this reference.
Parameters: by_spec : bool
If
True
, the return value is a dictionary with the polygons of each individual pair (layer, datatype).depth : integer or
None
If not
None
, defines from how many reference levels to retrieve polygons. References below this level will result in a bounding box. Ifby_spec
isTrue
the key will be the name of the referenced cell.Returns: out : list of array-like[N][2] or dictionary
List containing the coordinates of the vertices of each polygon, or dictionary with the list of polygons (if
by_spec
isTrue
).
-
to_gds
(multiplier)¶ Convert this object to a GDSII element.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII element.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the reference from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
CellReference
This object.
-
CellArray¶
-
class
gdspy.
CellArray
(ref_cell, columns, rows, spacing, origin=(0, 0), rotation=None, magnification=None, x_reflection=False)¶ Bases:
object
Multiple references to an existing cell in an array format.
Parameters: ref_cell :
Cell
or stringThe referenced cell or its name.
columns : positive integer
Number of columns in the array.
rows : positive integer
Number of columns in the array.
spacing : array-like[2]
distances between adjacent columns and adjacent rows.
origin : array-like[2]
Position where the cell is inserted.
rotation : number
Angle of rotation of the reference (in degrees).
magnification : number
Magnification factor for the reference.
x_reflection : bool
If
True
, the reference is reflected parallel to the x direction before being rotated.Methods
-
area
(by_spec=False)¶ Calculate the total area of the cell array with the magnification factor included.
Parameters: by_spec : bool
If
True
, the return value is a dictionary with the areas of each individual pair (layer, datatype).Returns: out : number, dictionary
Area of this cell.
-
get_bounding_box
()¶ Returns the bounding box for this reference.
Returns: out : Numpy array[2,2] or
None
Bounding box of this cell [[x_min, y_min], [x_max, y_max]], or
None
if the cell is empty.
-
get_polygons
(by_spec=False, depth=None)¶ Returns a list of polygons created by this reference.
Parameters: by_spec : bool
If
True
, the return value is a dictionary with the polygons of each individual pair (layer, datatype).depth : integer or
None
If not
None
, defines from how many reference levels to retrieve polygons. References below this level will result in a bounding box. Ifby_spec
isTrue
the key will be name of the referenced cell.Returns: out : list of array-like[N][2] or dictionary
List containing the coordinates of the vertices of each polygon, or dictionary with the list of polygons (if
by_spec
isTrue
).
-
to_gds
(multiplier)¶ Convert this object to a GDSII element.
Parameters: multiplier : number
A number that multiplies all dimensions written in the GDSII element.
Returns: out : string
The GDSII binary string that represents this object.
-
translate
(dx, dy)¶ Move the reference from one place to another
Parameters: dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
CellArray
This object.
-
Functions¶
fast_boolean¶
-
gdspy.
fast_boolean
(operandA, operandB, operation, precision=0.001, max_points=199, layer=0, datatype=0)¶ Execute any boolean operation between 2 polygons or polygon sets.
Parameters: operandA : polygon or array-like
First operand. Must be a
Polygon
,PolygonSet
,CellReference
,CellArray
, or an array. The array may contain any of the previous objects or an array-like[N][2] of vertices of a polygon.operandB : polygon, array-like or
None
Second operand. Must be
None
, aPolygon
,PolygonSet
,CellReference
,CellArray
, or an array. The array may contain any of the previous objects or an array-like[N][2] of vertices of a polygon.operation : {‘or’, ‘and’, ‘xor’, ‘not’}
Boolean operation to be executed. The ‘not’ operation returns the difference
operandA - operandB
.precision : float
Desired precision for rounding vertice coordinates.
max_points : integer
If greater than 4, fracture the resulting polygons to ensure they have at most
max_points
vertices. This is not a tessellating function, so this number should be as high as possible. For example, it should be set to 199 for polygons being drawn in GDSII files.layer : integer
The GDSII layer number for the resulting element.
datatype : integer
The GDSII datatype for the resulting element (between 0 and 255).
Returns: out : PolygonSet or
None
Result of the boolean operation.
boolean¶
-
gdspy.
boolean
(polygons, operation, max_points=199, layer=0, datatype=0, eps=1e-13)¶ This function is deprecated in favor of ‘fast_boolean’.
Execute any generalized boolean operation on polygons and polygon sets.
Parameters: polygons : array-like
Operands of the boolean operation. Each element of this array must be a
Polygon
,PolygonSet
,CellReference
,CellArray
, or an array-like[N][2] of vertices of a polygon.operation : function
Function that accepts as input
len(polygons)
integers. Each integer represents the incidence of the correspondingpolygon
. The function must return a bool or integer (interpreted as bool).max_points : integer
If greater than 4, fracture the resulting polygons to ensure they have at most
max_points
vertices. This is not a tessellating function, so this number should be as high as possible. For example, it should be set to 199 for polygons being drawn in GDSII files.layer : integer
The GDSII layer number for the resulting element.
datatype : integer
The GDSII datatype for the resulting element (between 0 and 255).
eps : positive number
Small number to be used as tolerance in intersection and overlap calculations.
Returns: out : PolygonSet or
None
Result of the boolean operation.
Notes
Since
operation
receives a list of integers as input, it can be somewhat more general than boolean operations only. See the examples below.Because of roundoff errors there are a few cases when this function can cause segmentation faults. If that happens, increasing the value of
eps
might help.Examples
>>> circle = gdspy.Round((0, 0), 10) >>> triangle = gdspy.Round((0, 0), 12, number_of_points=3) >>> bad_poly = gdspy.L1Path((0, 0), '+y', 2, [6, 4, 4, 8, 4, 5, 10], [-1, -1, -1, 1, 1, 1]) >>> union = gdspy.boolean([circle, triangle], lambda cir, tri: cir or tri) >>> intersection = gdspy.boolean([circle, triangle], lambda cir, tri: cir and tri) >>> subtraction = gdspy.boolean([circle, triangle], lambda cir, tri: cir and not tri) >>> multi_xor = gdspy.boolean([badPath], lambda p: p % 2)
offset¶
-
gdspy.
offset
(polygons, distance, join='miter', tolerance=2, precision=0.001, join_first=False, max_points=199, layer=0, datatype=0)¶ Shrink or expand a polygon or polygon set.
Parameters: polygons : polygon or array-like
Polygons to be offset. Must be a
Polygon
,PolygonSet
,CellReference
,CellArray
, or an array. The array may contain any of the previous objects or an array-like[N][2] of vertices of a polygon.distance : number
Offset distance. Positive to expand, negative to shrink.
join : {‘miter’, ‘bevel’, ‘round’}
Type of join used to create the offset polygon.
tolerance : integer or float
For miter joints, this number must be at least 2 and it represents the maximun distance in multiples of offset betwen new vertices and their original position before beveling to avoid spikes at acute joints. For round joints, it indicates the curvature resolution in number of points per full circle.
precision : float
Desired precision for rounding vertice coordinates.
join_first : bool
Join all paths before offseting to avoid unecessary joins in adjacent polygon sides.
max_points : integer
If greater than 4, fracture the resulting polygons to ensure they have at most
max_points
vertices. This is not a tessellating function, so this number should be as high as possible. For example, it should be set to 199 for polygons being drawn in GDSII files.layer : integer
The GDSII layer number for the resulting element.
datatype : integer
The GDSII datatype for the resulting element (between 0 and 255).
Returns: out :
PolygonSet
orNone
Return the offset shape as a set of polygons.
slice¶
-
gdspy.
slice
(objects, position, axis, layer=0, datatype=0)¶ Slice polygons and polygon sets at given positions along an axis.
Parameters: objects :
Polygon
,PolygonSet
, or listOperand of the slice operation. If this is a list, each element must be a
Polygon
,PolygonSet
,CellReference
,CellArray
, or an array-like[N][2] of vertices of a polygon.position : number or list of numbers
Positions to perform the slicing operation along the specified axis.
axis : 0 or 1
Axis along which the polygon will be sliced.
layer : integer, list
The GDSII layer numbers for the elements between each division. If the number of layers in the list is less than the number of divided regions, the list is repeated.
datatype : integer
The GDSII datatype for the resulting element (between 0 and 255).
Returns: out : list[N] of PolygonSet
Result of the slicing operation, with N = len(positions) + 1. Each PolygonSet comprises all polygons between 2 adjacent slicing positions, in crescent order.
Examples
>>> ring = gdspy.Round((0, 0), 10, inner_radius = 5) >>> result = gdspy.slice(ring, [-7, 7], 0) >>> cell.add(result[1])
inside¶
-
gdspy.
inside
(points, polygons, short_circuit='any', precision=0.001)¶ Test whether each of the points is within the given set of polygons.
Parameters: points : array-like[N][2] or list of array-like[N][2]
Coordinates of the points to be tested or groups of points to be tested together.
polygons : polygon or array-like
Polygons to be tested against. Must be a
Polygon
,PolygonSet
,CellReference
,CellArray
, or an array. The array may contain any of the previous objects or an array-like[N][2] of vertices of a polygon.short_circuit : {‘any’, ‘all’}
If points is a list of point groups, testing within each group will be short-circuited if any of the points in the group is inside (‘any’) or outside (‘all’) the polygons. If points is simply a list of points, this parameter has no effect.
precision : float
Desired precision for rounding vertice coordinates.
Returns: out : list
List of booleans indicating if each of the points or point groups is inside the set of polygons.
copy¶
-
gdspy.
copy
(obj, dx, dy)¶ Creates a copy of
obj
and translates the new object to a new location.Parameters: obj :
obj
any translatable geometery object.
dx : float
distance to move in the x-direction
dy : float
distance to move in the y-direction
Returns: out :
obj
Translated copy of original
obj
Examples
>>> rectangle = gdspy.Rectangle((0, 0), (10, 20)) >>> rectangle2 = gdspy.copy(rectangle, 2,0) >>> myCell.add(rectangle) >>> myCell.add(rectangle2)