def _getArcPrimitives(self):
line_width = self.round_radius * 2
step = self._getStep()
r_inner = self.reference_arc.getRadius(
) - self.width / 2 + line_width / 2
r_outer = self.reference_arc.getRadius(
) + self.width / 2 - line_width / 2
ref_arc = Arc(geometry=self.reference_arc,
width=line_width).setRadius(r_outer)
nodes = []
r = r_inner
while r < r_outer:
nodes.append(ref_arc.copy().setRadius(r))
r += step
nodes.append(ref_arc)
if self.start_line is not None:
nodes = self.__cutArcs(nodes, self.start_line, 1)
if self.end_line is not None:
nodes = self.__cutArcs(nodes, self.end_line, 0)
nodes.append(
Line(start=nodes[0].getEndPoint(),
end=nodes[-1].getEndPoint(),
width=line_width))
nodes.append(
Line(start=nodes[0].getStartPoint(),
end=nodes[-2].getStartPoint(),
width=line_width))
return nodes
def _createChildNodes(self, polygone_line):
nodes = []
for line_start, line_end in zip(polygone_line, polygone_line[1:]):
new_node = Line(start=line_start, end=line_end, layer=self.layer, width=self.width)
new_node._parent = self
nodes.append(new_node)
return nodes
def _createChildNodes(self, polygone_line, **kwargs):
nodes = []
for line_start, line_end in zip(polygone_line, polygone_line[1:]):
new_node = Line(start=line_start, end=line_end, **kwargs)
new_node._parent = self
nodes.append(new_node)
return nodes
def _createChildNodes(self, polygone_line, **kwargs):
nodes = []
for line_start, line_end in zip(polygone_line, polygone_line[1:]):
new_node = Line(start=line_start, end=line_end, **kwargs)
new_node._parent = self
nodes.append(new_node)
return nodes
def _createChildNodes(self, polygone_line):
nodes = []
for line_start, line_end in zip(polygone_line, polygone_line[1:]):
new_node = Line(start=line_start, end=line_end, layer=self.layer, width=self.width)
new_node._parent = self
nodes.append(new_node)
return nodes
def _createFFabLine(self):
ffabline = []
self.boxffabline = []
#
#
x = self.at.x
y = self.at.y
w = self.size.x
h = self.size.y
self.boxffabline.append(
koaLine(x, y, x + w, y, 'F.Fab', self.FFabWidth))
self.boxffabline.append(
koaLine(x + w, y, x + w, y + h, 'F.Fab', self.FFabWidth))
self.boxffabline.append(
koaLine(x + w, y + h, x, y + h, 'F.Fab', self.FFabWidth))
self.boxffabline.append(
koaLine(x, y + h, x, y, 'F.Fab', self.FFabWidth))
#
# Add a chamfer
#
dd = 0.5
if w < 2.0:
dd = w / 3.0
if h < 2.0:
dd = h / 3.0
#
x1 = x + dd
y1 = y + dd
w1 = w - dd
ffabline.append(koaLine(x1, y, x1 + w1, y, 'F.Fab', self.FFabWidth))
ffabline.append(
koaLine(x1 + w1, y, x1 + w1, y + h, 'F.Fab', self.FFabWidth))
ffabline.append(
koaLine(x + w, y + h, x, y + h, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x, y + h, x, y1, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x, y1, x1, y, 'F.Fab', self.FFabWidth))
#
#
for n in ffabline:
new_node = Line(start=Point2D(n.sx, n.sy),
end=Point2D(n.ex, n.ey),
layer=n.layer,
width=n.width)
if n.width < 0.0:
new_node = Line(start=Point2D(n.sx, n.sy),
end=Point2D(n.ex, n.ey),
layer=n.layer)
new_node._parent = self
self.virtual_childs.append(new_node)
def _createPin1MarkerLine(self):
#
# Add pin 1 marker line
#
x1 = self.at.x - 0.5
y1 = self.at.y - 0.5
#
new_node = Line(start=Point2D(round(x1, 2), round(y1 + self.p1m, 2)), end=Point2D(round(x1, 2), round(y1, 2)), layer='F.SilkS', width=self.FSilkSWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(round(x1, 2), round(y1, 2)), end=Point2D(round(x1 + self.p1m, 2), round(y1, 2)), layer='F.SilkS', width=self.FSilkSWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
def _createPin1MarkerLine(self):
#
# Add pin 1 marker line
#
x1 = self.at.x - 0.5
y1 = self.at.y - 0.5
#
new_node = Line(start=Point2D(x1, y1 + self.p1m), end=Point2D(x1, y1), layer='F.SilkS', width=self.FSilkSWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x1, y1), end=Point2D(x1 + self.p1m, y1), layer='F.SilkS', width=self.FSilkSWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
def _createFCrtYdLine(self):
self.fcrtydline = []
#
#
#
# Check all holes and pads, if a pad or hole is on the crtyrd line
# then jump over the pad/hole
#
for n in self.boxffabline:
x1 = min(n.sx, n.ex)
y1 = min(n.sy, n.ey)
x2 = max(n.sx, n.ex)
y2 = max(n.sy, n.ey)
#
#
if (x1 < 0.0 and y1 < 0.0 and y2 < 0.0) or (x1 < 0.0 and y1 > 0.0 and y2 > 0.0):
#
# Top and bottom line
#
x1_t = x1 - 0.25
x2_t = x2 + 0.25
x3_t = x1_t
x4_t = x2_t
#
if y1 < 0.0:
# Top line
y1_t = y1 - 0.25
y2_t = y2 - 0.25
y3_t = y1_t
y4_t = y2_t
#
for nn in self.corners:
if nn[0] == 'URR':
x2_t = x2_t - (nn[1] + 0.25)
if nn[0] == 'ULR':
x1_t = x1_t + (nn[1] + 0.25)
if nn[0] == 'ULP':
x3_t = x1_t
x1_t = x1_t + (nn[1])
y3_t = y1_t + (nn[2])
if nn[0] == 'URP':
x4_t = x2_t
x2_t = x2_t - (nn[1])
y4_t = y1_t + (nn[2])
else:
# Bottom line
y1_t = y1 + 0.25
y2_t = y2 + 0.25
y3_t = y1_t
y4_t = y2_t
#
for nn in self.corners:
if nn[0] == 'LRR':
x2_t = x2_t - (nn[1] + 0.25)
if nn[0] == 'LLR':
x1_t = x1_t + (nn[1] + 0.25)
if nn[0] == 'LLP':
x3_t = x1_t
x1_t = x1_t + (nn[1])
y3_t = y1_t - (nn[2])
if nn[0] == 'LRP':
x4_t = x2_t
x2_t = x2_t - (nn[1])
y4_t = y1_t - (nn[2])
#
EndLine = True
UseCorner = True
while EndLine:
px1 = 10000000.0
py1 = 10000000.0
px2 = 10000000.0
py2 = 10000000.0
foundPad = False
for n in self.pad:
n_min_x = n.at.x - (n.size.x / 2.0)
n_min_y = n.at.y - (n.size.y / 2.0)
n_max_x = n_min_x + n.size.x
n_max_y = n_min_y + n.size.y
dd = max(0.25, n.solder_mask_margin)
if (n_min_y - dd) <= y1_t and (n_max_y + dd) > y1_t and n_max_x > x1_t and n_min_x < x2_t:
#
# This pad is in CrtYd line's path
#
if n_min_x < px1:
px1 = n_min_x
py1 = n_min_y
px2 = n_max_x
py2 = n_max_y
foundPad = True
if foundPad:
#
# Found at least one pad that is in CrtYd's line
#
if (px1 - dd) > x1_t:
#
# It does not cover the start point
#
self.fcrtydline.append(koaLine(x1_t, y1_t, px1 - dd, y2_t, 'F.CrtYd', self.FCrtYdWidth))
if y1 < 0.0:
# Top line
self.fcrtydline.append(koaLine(px1 - dd, y2_t, px1 - dd, py1 - dd, 'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px1 - dd, py1 - dd, px2 + dd, py1 - dd, 'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px2 + dd, py1 - dd, px2 + dd, y2_t, 'F.CrtYd', self.FCrtYdWidth))
else:
# Bottom line
self.fcrtydline.append(koaLine(px1 - dd, y2_t, px1 - dd, py2 + dd, 'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px1 - dd, py2 + dd, px2 + dd, py2 + dd, 'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px2 + dd, py2 + dd, px2 + dd, y2_t, 'F.CrtYd', self.FCrtYdWidth))
x1_t = px2 + dd
else:
#
# No pads was in the way
#
#
# No pads was in the way
#
if y1 < 0.0 and UseCorner:
# Top line
for nn in self.corners:
if nn[0] == 'ULR':
urcdy0 = y1_t + (nn[1] + 0.25)
urcdx1 = x1_t - (nn[1] + 0.25)
new_node = Arc(center=Point2D(x1_t, urcdy0), start=Point2D(urcdx1, urcdy0), layer='F.CrtYd', width=self.FCrtYdWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'ULP':
new_node = Line(start=Point2D(x1_t, y3_t), end=Point2D(x1_t, y1_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
new_node = Line(start=Point2D(x1_t, y3_t), end=Point2D(x3_t, y3_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
if nn[0] == 'URP':
urcdy0 = y4_t + (nn[2])
new_node = Line(start=Point2D(x2_t, y4_t), end=Point2D(x2_t, y2_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
new_node = Line(start=Point2D(x2_t, y4_t), end=Point2D(x4_t, y4_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if y1 > 0.0 and UseCorner:
# Bottom line
for nn in self.corners:
if nn[0] == 'LLR':
urcdy0 = y1_t - (nn[1] + 0.25)
new_node = Arc(center=Point2D(x1_t, urcdy0), start=Point2D(x1_t, y1_t), layer='F.CrtYd', width=self.FCrtYdWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LLP':
new_node = Line(start=Point2D(x1_t, y3_t), end=Point2D(x1_t, y1_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
new_node = Line(start=Point2D(x1_t, y3_t), end=Point2D(x3_t, y3_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
if nn[0] == 'LRP':
urcdy0 = y4_t + (nn[2])
new_node = Line(start=Point2D(x2_t, y4_t), end=Point2D(x2_t, y2_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
new_node = Line(start=Point2D(x2_t, y4_t), end=Point2D(x4_t, y4_t), layer='F.CrtYd', width=self.FCrtYdWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
self.fcrtydline.append(koaLine(x1_t, y1_t, x2_t, y2_t, 'F.CrtYd', self.FCrtYdWidth))
EndLine = False
UseCorner = False
if x1_t >= x2:
EndLine = False
if not foundPad and y1 < 0:
#
for nn in self.corners:
if nn[0] == 'URR':
urcdy1 = y1_t + (nn[1] + 0.25)
new_node = Arc(center=Point2D(x2_t, urcdy1), start=Point2D(x2_t, y2_t), layer='F.CrtYd', width=self.FCrtYdWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if not foundPad and y1 > 0:
#
for nn in self.corners:
if nn[0] == 'LRR':
urcdx1 = x2_t + (nn[1] + 0.25)
urcdy1 = y2_t - (nn[1] + 0.25)
new_node = Arc(center=Point2D(x2_t, urcdy1), start=Point2D(urcdx1, urcdy1), layer='F.CrtYd', width=self.FCrtYdWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if (x1 < 0.0 and y1 < 0.0 and y2 > 0.0) or (x1 > 0.0 and y1 < 0.0 and y2 > 0.0):
#
# Left and right line
#
y1_t = y1 - 0.25
y2_t = y2 + 0.25
#
if x1 < 0.0:
# Left line
x1_t = x1 - 0.25
x2_t = x1 - 0.25
#
for nn in self.corners:
if nn[0] == 'ULR':
y1_t = y1_t + (nn[1] + 0.25)
if nn[0] == 'LLR':
y2_t = y2_t - (nn[1] + 0.25)
if nn[0] == 'ULP':
y1_t = y1_t + (nn[2])
if nn[0] == 'LLP':
y2_t = y2_t - (nn[2])
else:
# Right line
x1_t = x1 + 0.25
x2_t = x2 + 0.25
#
for nn in self.corners:
if nn[0] == 'URR':
y1_t = y1_t + (nn[1] + 0.25)
if nn[0] == 'LRR':
y2_t = y2_t - (nn[1] + 0.25)
if nn[0] == 'URP':
y1_t = y1_t + (nn[2])
if nn[0] == 'LRP':
y2_t = y2_t - (nn[2])
#
EndLine = True
while EndLine:
px1 = 10000000.0
py1 = 10000000.0
px2 = 10000000.0
py2 = 10000000.0
foundPad = False
for n in self.pad:
n_min_x = n.at.x - (n.size.x / 2.0)
n_min_y = n.at.y - (n.size.y / 2.0)
n_max_x = n_min_x + n.size.x
n_max_y = n_min_y + n.size.y
dd = max(0.26, n.solder_mask_margin)
if (n_min_x <= x1_t) and (n_max_x >= x1_t) and n_max_y >= y1_t and n_min_y <= y2_t:
#
# This pad is in CrtYd line's path
#
if n_min_y < py1:
px1 = n_min_x
py1 = n_min_y
px2 = n_max_x
py2 = n_max_y
foundPad = True
if foundPad:
#
# Found at least one pad that is in CrtYd's line
#
if (py1 - dd) > y1_t:
#
# It does not cover the start point
#
self.fcrtydline.append(koaLine(x1_t, y1_t, x2_t, py1 - dd, 'F.CrtYd', self.FCrtYdWidth))
if x1 < 0.0:
# Left line
self.fcrtydline.append(koaLine(x2_t, py1 - dd, px1 - dd, py1 - dd,
'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px1 - dd, py1 - dd, px1 - dd, py2 + dd,
'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px1 - dd, py2 + dd, x2_t, py2 + dd,
'F.CrtYd', self.FCrtYdWidth))
else:
# Right line
self.fcrtydline.append(koaLine(x2_t, py1 - dd, px2 + dd, py1 - dd,
'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px2 + dd, py1 - dd, px2 + dd, py2 + dd,
'F.CrtYd', self.FCrtYdWidth))
self.fcrtydline.append(koaLine(px2 + dd, py2 + dd, x2_t, py2 + dd,
'F.CrtYd', self.FCrtYdWidth))
y1_t = py2 + dd
else:
#
# No pads was in the way
#
self.fcrtydline.append(koaLine(x1_t, y1_t, x2_t, y2_t, 'F.CrtYd', self.FCrtYdWidth))
EndLine = False
if y1_t >= y2:
EndLine = False
#
#
for n in self.fcrtydline:
new_node = Line(start=Point2D(n.sx, n.sy), end=Point2D(n.ex, n.ey), layer=n.layer, width=n.width)
if n.width < 0.0:
new_node = Line(start=Point2D(n.sx, n.sy), end=Point2D(n.ex, n.ey), layer=n.layer)
new_node._parent = self
self.virtual_childs.append(new_node)
def _createFFabLine(self):
ffabline = []
self.boxffabline = []
#
#
x = self.at.x
y = self.at.y
w = self.size.x
h = self.size.y
self.boxffabline.append(koaLine(x, y, x + w, y, 'F.Fab', self.FFabWidth))
self.boxffabline.append(koaLine(x + w, y, x + w, y + h, 'F.Fab', self.FFabWidth))
self.boxffabline.append(koaLine(x + w, y + h, x, y + h, 'F.Fab', self.FFabWidth))
self.boxffabline.append(koaLine(x, y + h, x, y, 'F.Fab', self.FFabWidth))
#
# Add a chamfer
#
dd = 0.5
if w < 2.0:
dd = w / 3.0
if h < 2.0:
dd = h / 3.0
#
#
x0 = x + dd
y0 = y
x9 = x0
y9 = y0
#
x1 = x + w
y1 = y
x2 = x1
y2 = y1
#
x3 = x + w
y3 = y + h
x4 = x3
y4 = y3
#
x5 = x
y5 = y + h
x6 = x5
y6 = y5
#
x7 = x
y7 = y + dd
x8 = x7
y8 = y7
#
#
for nn in self.corners:
if nn[0] == 'ULP':
x0 = x + nn[1]
x9 = x0
y8 = y + nn[2]
y9 = y8
y7 = y8
new_node = Line(start=Point2D(x9, y9), end=Point2D(x0, y0), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'ULR':
x0 = x + nn[1]
y7 = y + nn[1]
x8 = x7
x9 = x7
y8 = y7
y9 = y7
new_node = Arc(center=Point2D(x0, y7), start=Point2D(x7, y7), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'URP':
x1 = (x + w) - nn[1]
y2 = y + nn[2]
new_node = Line(start=Point2D(x1, y1), end=Point2D(x1, y2), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x1, y2), end=Point2D(x2, y2), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'URR':
x1 = (x + w) - nn[1]
y2 = y + nn[1]
new_node = Arc(center=Point2D(x1, y2), start=Point2D(x1, y1), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LRP':
x4 = (x + w) - nn[1]
y3 = (y + h) - nn[1]
new_node = Line(start=Point2D(x3, y3), end=Point2D(x4, y3), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x4, y3), end=Point2D(x4, y4), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LRR':
x4 = (x + w) - nn[1]
y3 = (y + h) - nn[1]
new_node = Arc(center=Point2D(x4, y3), start=Point2D(x3, y3), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LLR':
x5 = x + nn[1]
y6 = (y + h) - nn[1]
new_node = Arc(center=Point2D(x5, y6), start=Point2D(x5, y5), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LLP':
x5 = x + nn[1]
y6 = (y + h) - nn[2]
new_node = Line(start=Point2D(x5, y5), end=Point2D(x5, y6), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x5, y6), end=Point2D(x6, y6), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
ffabline.append(koaLine(x0, y0, x1, y1, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x2, y2, x3, y3, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x4, y4, x5, y5, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x6, y6, x7, y7, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x8, y8, x9, y9, 'F.Fab', self.FFabWidth))
#
#
for n in ffabline:
new_node = Line(start=Point2D(n.sx, n.sy), end=Point2D(n.ex, n.ey), layer=n.layer, width=n.width)
if n.width < 0.0:
new_node = Line(start=Point2D(n.sx, n.sy), end=Point2D(n.ex, n.ey), layer=n.layer)
new_node._parent = self
self.virtual_childs.append(new_node)
def _createFCrtYdLine(self):
self.fcrtydline = []
#
#
#
# Check all holes and pads, if a pad or hole is on the silk line
# then jump over the pad/hole
#
for n in self.boxffabline:
x1 = min(n.sx, n.ex)
y1 = min(n.sy, n.ey)
x2 = max(n.sx, n.ex)
y2 = max(n.sy, n.ey)
#
#
if (x1 < 0.0 and y1 < 0.0 and y2 < 0.0) or (x1 < 0.0 and y1 > 0.0
and y2 > 0.0):
#
# Top and bottom line
#
x1_t = x1 - 0.25
x2_t = x2 + 0.25
#
if y1 < 0.0:
# Top line
y1_t = y1 - 0.25
y2_t = y2 - 0.25
else:
# Bottom line
y1_t = y1 + 0.25
y2_t = y2 + 0.25
#
EndLine = True
while EndLine:
px1 = 10000000.0
py1 = 10000000.0
px2 = 10000000.0
py2 = 10000000.0
foundPad = False
for n in self.pad:
n_min_x = n.at.x - (n.size.x / 2.0)
n_min_y = n.at.y - (n.size.y / 2.0)
n_max_x = n_min_x + n.size.x
n_max_y = n_min_y + n.size.y
dd = max(0.25, n.solder_mask_margin)
if (n_min_y - dd) <= y1_t and (
n_max_y + dd
) > y1_t and n_max_x > x1_t and n_min_x < x2_t:
#
# This pad is in SilkS line's path
#
if n_min_x < px1:
px1 = n_min_x
py1 = n_min_y
px2 = n_max_x
py2 = n_max_y
foundPad = True
if foundPad:
#
# Found at least one pad that is in SilkS's line
#
if (px1 - dd) > x1_t:
#
# It does not cover the start point
#
self.fsilksline.append(
koaLine(x1_t, y1_t, px1 - dd, y2_t, 'F.CrtYd',
self.FSilkSWidth))
if y1 < 0.0:
# Top line
self.fsilksline.append(
koaLine(px1 - dd, y2_t, px1 - dd, py1 - dd,
'F.CrtYd', self.FSilkSWidth))
self.fsilksline.append(
koaLine(px1 - dd, py1 - dd, px2 + dd,
py1 - dd, 'F.CrtYd',
self.FSilkSWidth))
self.fsilksline.append(
koaLine(px2 + dd, py1 - dd, px2 + dd, y2_t,
'F.CrtYd', self.FSilkSWidth))
else:
# Bottom line
self.fsilksline.append(
koaLine(px1 - dd, y2_t, px1 - dd, py2 + dd,
'F.CrtYd', self.FSilkSWidth))
self.fsilksline.append(
koaLine(px1 - dd, py2 + dd, px2 + dd,
py2 + dd, 'F.CrtYd',
self.FSilkSWidth))
self.fsilksline.append(
koaLine(px2 + dd, py2 + dd, px2 + dd, y2_t,
'F.CrtYd', self.FSilkSWidth))
x1_t = px2 + dd
else:
#
# No pads was in the way
#
self.fsilksline.append(
koaLine(x1_t, y1_t, x2_t, y2_t, 'F.CrtYd',
self.FSilkSWidth))
EndLine = False
if x1_t >= x2:
EndLine = False
if (x1 < 0.0 and y1 < 0.0 and y2 > 0.0) or (x1 > 0.0 and y1 < 0.0
and y2 > 0.0):
#
# Left and right line
#
y1_t = y1 - 0.25
y2_t = y2 + 0.25
#
if x1 < 0.0:
# Left line
x1_t = x1 - 0.25
x2_t = x1 - 0.25
else:
# Right line
x1_t = x1 + 0.25
x2_t = x2 + 0.25
#
EndLine = True
while EndLine:
px1 = 10000000.0
py1 = 10000000.0
px2 = 10000000.0
py2 = 10000000.0
foundPad = False
for n in self.pad:
n_min_x = n.at.x - (n.size.x / 2.0)
n_min_y = n.at.y - (n.size.y / 2.0)
n_max_x = n_min_x + n.size.x
n_max_y = n_min_y + n.size.y
dd = max(0.25, n.solder_mask_margin)
if (n_min_x <= x1_t) and (
n_max_x >
x1_t) and n_max_y > y1_t and n_min_y < y2_t:
#
# This pad is in SilkS line's path
#
if n_min_y < py1:
px1 = n_min_x
py1 = n_min_y
px2 = n_max_x
py2 = n_max_y
foundPad = True
if foundPad:
#
# Found at least one pad that is in SilkS's line
#
if (py1 - dd) > y1_t:
#
# It does not cover the start point
#
self.fsilksline.append(
koaLine(x1_t, y1_t, x2_t, py1 - dd, 'F.CrtYd',
self.FSilkSWidth))
if x1 < 0.0:
# Left line
self.fsilksline.append(
koaLine(x2_t, py1 - dd, px1 - dd, py1 - dd,
'F.CrtYd', self.FSilkSWidth))
self.fsilksline.append(
koaLine(px1 - dd, py1 - dd, px1 - dd,
py2 + dd, 'F.CrtYd',
self.FSilkSWidth))
self.fsilksline.append(
koaLine(px1 - dd, py2 + dd, x2_t, py2 + dd,
'F.CrtYd', self.FSilkSWidth))
else:
# Right line
self.fsilksline.append(
koaLine(x2_t, py1 - dd, px2 + dd, py1 - dd,
'F.CrtYd', self.FSilkSWidth))
self.fsilksline.append(
koaLine(px2 + dd, py1 - dd, px2 + dd,
py2 + dd, 'F.CrtYd',
self.FSilkSWidth))
self.fsilksline.append(
koaLine(px2 + dd, py2 + dd, x2_t, py2 + dd,
'F.CrtYd', self.FSilkSWidth))
y1_t = py2 + dd
else:
#
# No pads was in the way
#
self.fsilksline.append(
koaLine(x1_t, y1_t, x2_t, y2_t, 'F.CrtYd',
self.FSilkSWidth))
EndLine = False
if y1_t >= y2:
EndLine = False
#
#
for n in self.fsilksline:
new_node = Line(start=Point2D(n.sx, n.sy),
end=Point2D(n.ex, n.ey),
layer=n.layer,
width=n.width)
if n.width < 0.0:
new_node = Line(start=Point2D(n.sx, n.sy),
end=Point2D(n.ex, n.ey),
layer=n.layer)
new_node._parent = self
self.virtual_childs.append(new_node)
def _createFFabLine(self):
ffabline = []
self.boxffabline = []
#
#
x = self.at.x
y = self.at.y
w = self.size.x
h = self.size.y
self.boxffabline.append(koaLine(x, y, x + w, y, 'F.Fab', self.FFabWidth))
self.boxffabline.append(koaLine(x + w, y, x + w, y + h, 'F.Fab', self.FFabWidth))
self.boxffabline.append(koaLine(x + w, y + h, x, y + h, 'F.Fab', self.FFabWidth))
self.boxffabline.append(koaLine(x, y + h, x, y, 'F.Fab', self.FFabWidth))
#
# Add a chamfer
#
dd = w * 0.25
if dd > 1.0:
dd = 1.0
if w < 2.0:
dd = w / 3.0
if h < 2.0:
dd = h / 3.0
#
#
x0 = x + dd
y0 = y
x9 = x0
y9 = y0
#
x1 = x + w
y1 = y
x2 = x1
y2 = y1
#
x3 = x + w
y3 = y + h
x4 = x3
y4 = y3
#
x5 = x
y5 = y + h
x6 = x5
y6 = y5
#
x7 = x
y7 = y + dd
x8 = x7
y8 = y7
#
#
for nn in self.corners:
if nn[0] == 'ULP':
x0 = x + nn[1]
x9 = x0
y8 = y + nn[2]
y9 = y8
y7 = y8
new_node = Line(start=Point2D(x9, y9), end=Point2D(x0, y0), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'ULR':
x0 = x + nn[1]
y7 = y + nn[1]
x8 = x7
x9 = x7
y8 = y7
y9 = y7
new_node = Arc(center=Point2D(x0, y7), start=Point2D(x7, y7), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'URP':
x1 = (x + w) - nn[1]
y2 = y + nn[2]
new_node = Line(start=Point2D(x1, y1), end=Point2D(x1, y2), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x1, y2), end=Point2D(x2, y2), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'URR':
x1 = (x + w) - nn[1]
y2 = y + nn[1]
new_node = Arc(center=Point2D(x1, y2), start=Point2D(x1, y1), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LRP':
x4 = (x + w) - nn[1]
y3 = (y + h) - nn[1]
new_node = Line(start=Point2D(x3, y3), end=Point2D(x4, y3), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x4, y3), end=Point2D(x4, y4), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LRR':
x4 = (x + w) - nn[1]
y3 = (y + h) - nn[1]
new_node = Arc(center=Point2D(x4, y3), start=Point2D(x3, y3), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LLR':
x5 = x + nn[1]
y6 = (y + h) - nn[1]
new_node = Arc(center=Point2D(x5, y6), start=Point2D(x5, y5), layer='F.Fab', width=self.FFabWidth, angle=90.0)
new_node._parent = self
self.virtual_childs.append(new_node)
if nn[0] == 'LLP':
x5 = x + nn[1]
y6 = (y + h) - nn[2]
new_node = Line(start=Point2D(x5, y5), end=Point2D(x5, y6), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
#
new_node = Line(start=Point2D(x5, y6), end=Point2D(x6, y6), layer='F.Fab', width=self.FFabWidth)
new_node._parent = self
self.virtual_childs.append(new_node)
ffabline.append(koaLine(x0, y0, x1, y1, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x2, y2, x3, y3, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x4, y4, x5, y5, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x6, y6, x7, y7, 'F.Fab', self.FFabWidth))
ffabline.append(koaLine(x8, y8, x9, y9, 'F.Fab', self.FFabWidth))
#
#
for n in ffabline:
new_node = Line(start=Point2D(round(n.sx, 2), round(n.sy, 2)), end=Point2D(round(n.ex, 2), round(n.ey, 2)), layer=n.layer, width=n.width)
if n.width < 0.0:
new_node = Line(start=Point2D(round(n.sx, 2), round(n.sy, 2)), end=Point2D(round(n.ex, 2), round(n.ey, 2)), layer=n.layer)
new_node._parent = self
self.virtual_childs.append(new_node)
