def trans(dpolygon, angle):
pts = []
c = cos(angle / 180 * pi)
s = sin(angle / 180 * pi)
for pt in dpolygon.each_point_hull():
pts.append(pya.DPoint(c * pt.x + s * pt.y, -s * pt.x + c * pt.y))
return pya.DPolygon(pts)
def __init__(self):
super(Ring_Modulator_DB, self).__init__()
# declare the parameters
from SiEPIC.utils import get_technology_by_name
TECHNOLOGY = get_technology_by_name('GSiP')
self.param("silayer", self.TypeLayer, "Si Layer", default = TECHNOLOGY['Si'])
self.param("s", self.TypeShape, "", default = pya.DPoint(0, 0))
self.param("r", self.TypeDouble, "Radius", default = 10)
self.param("w", self.TypeDouble, "Waveguide Width", default = 0.5)
self.param("g", self.TypeDouble, "Gap", default = 0.2)
self.param("gmon", self.TypeDouble, "Gap Monitor", default = 0.5)
self.param("component_ID", self.TypeInt, "Component_ID (>0)", default = 0)
self.param("si3layer", self.TypeLayer, "SiEtch2(Rib) Layer", default = TECHNOLOGY['SiEtch2'])
self.param("nlayer", self.TypeLayer, "N Layer", default = TECHNOLOGY['Si N'])
self.param("player", self.TypeLayer, "P Layer", default = TECHNOLOGY['Si P'])
self.param("nplayer", self.TypeLayer, "N+ Layer", default = TECHNOLOGY['Si N+'])
self.param("pplayer", self.TypeLayer, "P+ Layer", default = TECHNOLOGY['Si P+'])
self.param("npplayer", self.TypeLayer, "N++ Layer", default = TECHNOLOGY['Si N++'])
self.param("ppplayer", self.TypeLayer, "P++ Layer", default = TECHNOLOGY['Si P++'])
self.param("vclayer", self.TypeLayer, "VC Layer", default = TECHNOLOGY['VC'])
self.param("m1layer", self.TypeLayer, "M1 Layer", default = TECHNOLOGY['M1'])
self.param("vllayer", self.TypeLayer, "VL Layer", default = TECHNOLOGY['VL'])
self.param("mllayer", self.TypeLayer, "ML Layer", default = TECHNOLOGY['ML'])
self.param("mhlayer", self.TypeLayer, "MH Layer", default = TECHNOLOGY['M Heater'])
self.param("textpolygon", self.TypeInt, "Draw text polygon label? 0/1", default = 1)
self.param("textl", self.TypeLayer, "Text Layer", default = TECHNOLOGY['Text'])
self.param("pinrec", self.TypeLayer, "PinRec Layer", default = TECHNOLOGY['PinRec'])
self.param("devrec", self.TypeLayer, "DevRec Layer", default = TECHNOLOGY['DevRec'])
def __init__(self):
# Important: initialize the super class
super(Arrow, self).__init__()
# declare the parameters
self.param("l", self.TypeLayer, "Layer", default = pya.LayerInfo(1, 0))
self.param("hb", self.TypeShape, "", default = pya.DPoint(0.5, -6))
self.param("hh", self.TypeShape, "", default = pya.DPoint(0, 4))
self.param("ha", self.TypeShape, "", default = pya.DPoint(2.2314069574087765, 0))
self.param("b", self.TypeDouble, "Body length", default = 6)
self.param("h", self.TypeDouble, "Head length", default = 4)
self.param("a", self.TypeDouble, "Head angle", default = 45)
self.param("w", self.TypeDouble, "Body width", default = 1)
self.param("b_", self.TypeDouble, "Body length", default = 6, hidden = True)
self.param("h_", self.TypeDouble, "Head length", default = 4, hidden = True)
self.param("a_", self.TypeDouble, "Head angle", default = 45, hidden = True)
self.param("w_", self.TypeDouble, "Body width", default = 1, hidden = True)
def TurningArc(self,radius,angle=90):
#radius非负向右，负是向左
if angle<0:
angle=-angle
radius=-radius
delta=self.pointr.distance(self.pointl)
dx=(self.pointr.x-self.pointl.x)/delta
dy=(self.pointr.y-self.pointl.y)/delta
dtheta=atan2(dy,dx)*180/pi
centerx=self.pointr.x+(radius-delta/2)*dx
centery=self.pointr.y+(radius-delta/2)*dy
center=pya.DPoint(centerx,centery)
n=int(ceil((abs(radius)+delta/2)*angle*pi/180/IO.pointdistance)+2)
if radius>=0:
thickarc1,pointr2,pointl2=BasicPainter.thickarc(center,radius-delta/2,radius+delta/2,n,dtheta+180,dtheta+180-angle)
cpts=BasicPainter.arc(center,radius,n,dtheta+180,dtheta+180-angle)
else:
thickarc1,pointr2,pointl2=BasicPainter.thickarc(center,-radius+delta/2,-radius-delta/2,n,dtheta,dtheta+angle)
cpts=BasicPainter.arc(center,-radius,n,dtheta,dtheta+angle)
self.outputlist.append(thickarc1)
self.pointr=pointr2
self.pointl=pointl2
if self.centerlinepts==[]:
self.centerlinepts=cpts
else:
self.centerlinepts.extend(cpts[1:])
return pi*angle/180*abs(radius)
def getbrush2(pt, groupi):
ax = abs(pt.x)
ay = abs(pt.y - 400000)
dl = 100000
if ax >= ay and pt.x >= 0:
dx = dl
dy = 0
angle = 180
if ax >= ay and pt.x < 0:
dx = -dl
dy = 0
angle = 0
if ax < ay and pt.y >= 0:
dx = 0
dy = dl
angle = 270
if ax < ay and pt.y < 0:
dx = 0
dy = -dl
angle = 90
return paintlib.CavityBrush(pointc=pya.DPoint(pt.x + dx, pt.y + dy),
angle=angle,
widout=20000,
widin=10000,
bgn_ext=0)
def circle(x,y,r):
npts = 180
theta = 2*math.pi/npts
pts = []
for i in range(0,npts):
pts.append(Point.from_dpoint(pya.DPoint((x+r*math.cos(i*theta))/1,(y+r*math.sin(i*theta))/1)))
return pts
def arc_xy(x, y, r, theta_start, theta_stop, DevRec=None):
# function to draw an arc of waveguide
# radius: radius
# w: waveguide width
# length units in dbu
# theta_start, theta_stop: angles for the arc
# angles in degrees
from math import pi, cos, sin
from . import points_per_circle
circle_fraction = abs(theta_stop - theta_start) / 360.0
npoints = int(points_per_circle(r / 1000) * circle_fraction)
if DevRec:
npoints = int(npoints / 3)
if npoints == 0:
npoints = 1
da = 2 * pi / npoints * circle_fraction # increment, in radians
pts = []
th = theta_start / 360.0 * 2 * pi
for i in range(0, npoints + 1):
pts.append(
pya.Point.from_dpoint(
pya.DPoint((x + r * cos(i * da + th)) / 1,
(y + r * sin(i * da + th)) / 1)))
return pts
def bezier_optimal(P0, P3, *args, **kwargs):
P0 = Point(P0.x, P0.y)
P3 = Point(P3.x, P3.y)
scale = (P3 - P0).norm() # rough length.
# if scale > 1000: # if in nanometers, convert to microns
# scale /= 1000
# This function returns a Line object, needs to convert to array of Points
new_bezier_line = _bezier_optimal_pure(P0, P3, *args, **kwargs)
bezier_point_coordinates = lambda t: np.array(
[new_bezier_line(t).x, new_bezier_line(t).y])
_, bezier_point_coordinates_sampled = \
sample_function(bezier_point_coordinates, [0, 1], tol=0.001 / scale) # tol about 1 nm
# # This yields a better polygon
bezier_point_coordinates_sampled = \
np.insert(bezier_point_coordinates_sampled, 1, bezier_point_coordinates(.001 / scale),
axis=1) # add a point right after the first one
bezier_point_coordinates_sampled = \
np.insert(bezier_point_coordinates_sampled, -1, bezier_point_coordinates(1 - .001 / scale),
axis=1) # add a point right before the last one
# bezier_point_coordinates_sampled = \
# np.append(bezier_point_coordinates_sampled, np.atleast_2d(bezier_point_coordinates(1 + .001 / scale)).T,
# axis=1) # finish the waveguide a little bit after
return [
pya.DPoint(x, y)
for (x, y) in zip(*(bezier_point_coordinates_sampled))
]
def _Straight(self, length, centerline=False):
n = int(ceil(length / IO.pointdistance)) + 2
if n == 1:
n = 2
n *= IO.centerlineratio
p1x = self.pointr.x / 2 + self.pointl.x / 2
p1y = self.pointr.y / 2 + self.pointl.y / 2
# 接下来是画矩形，再之后是画中心线
# 修复1nm线的bug
rectangle1, _, _ = BasicPainter.rectangle(
self.pointr, self.pointl, length + (length > 0) - (length < 0))
_, self.pointr, self.pointl = BasicPainter.rectangle(
self.pointr, self.pointl, length)
self.outputlist.append(rectangle1)
#
dx = self.pointr.x / 2 + self.pointl.x / 2 - p1x
dy = self.pointr.y / 2 + self.pointl.y / 2 - p1y
cpts = [
pya.DPoint(p1x + 1.0 * pt / (n - 1) * dx,
p1y + 1.0 * pt / (n - 1) * dy) for pt in range(n)
]
if centerline:
if self.centerlinepts == []:
self.centerlinepts = cpts
else:
self.centerlinepts.extend(cpts[1:])
return length
def hexagon_half(a):
theta_div = math.pi/3
triangle_length = a/math.sqrt(3)
pts = []
for i in range(0,4):
pts.append(Point.from_dpoint(pya.DPoint(triangle_length*math.cos(i*theta_div-math.pi/2), triangle_length*math.sin(i*theta_div-math.pi/2))))
return pts
def circle(x,y,r):
npts = n_vertices
theta = 2 * math.pi / npts # increment, in radians
pts = []
for i in range(0, npts):
pts.append(Point.from_dpoint(pya.DPoint((x+r*math.cos(i*theta))/1, (y+r*math.sin(i*theta))/1)))
return pts
def TurningInterpolation(self, radius, angle=90): #有待改进
#radius非负向右，负是向左
pass
if angle < 0:
angle = -angle
radius = -radius
angle = 90
delta = self.pointr.distance(self.pointl)
dx = (self.pointr.x - self.pointl.x) / delta
dy = (self.pointr.y - self.pointl.y) / delta
dtheta = atan2(dy, dx) * 180 / pi
centerx = self.pointr.x + (radius - delta / 2) * dx
centery = self.pointr.y + (radius - delta / 2) * dy
n = int(
ceil(1.3 * (abs(radius) + delta / 2) * angle * pi / 180 /
IO.pointdistance) + 2)
#
rsgn = (radius > 0) - (radius < 0)
pointr2 = pya.DPoint(centerx - rsgn * (radius - delta / 2) * dy,
centery + rsgn * (radius - delta / 2) * dx)
pointl2 = pya.DPoint(centerx - rsgn * (radius + delta / 2) * dy,
centery + rsgn * (radius + delta / 2) * dx)
pts1 = BasicPainter.arc_NewtonInterpolation(n, abs(radius) + delta / 2)
pts2 = BasicPainter.arc_NewtonInterpolation(n, abs(radius) - delta / 2)
pts1.extend(reversed(pts2))
arc1 = pya.DPolygon(pts1)
trans = pya.DCplxTrans(1, 180 + dtheta + 45 * rsgn, False, centerx,
centery)
arc1.transform(trans)
self.outputlist.append(arc1)
self.pointr = pointr2
self.pointl = pointl2
pts3 = BasicPainter.arc_NewtonInterpolation(n, abs(radius))
cpts = [
pya.DEdge(pya.DPoint(), pt).transformed(trans).p2 for pt in pts3
]
if abs(cpts[-1].distance(self.pointr) - delta / 2) < IO.pointdistance:
if self.centerlinepts == []:
self.centerlinepts = cpts
else:
self.centerlinepts.extend(cpts[1:])
else:
if self.centerlinepts == []:
self.centerlinepts = cpts[::-1]
else:
self.centerlinepts.extend(cpts[-2::-1])
return pi * 0.5 * abs(radius)
def Getexinfo(self):
# la lb la lb la
# p1 p2 p3 p4 p5 p6
brush = self.brush
widout = brush.edgeout.length()
widin = brush.edgein.length()
p1 = brush.edgeout.p1
p2 = brush.edgein.p1
p5 = brush.edgein.p2
p6 = brush.edgeout.p2
la = (widout - widin) / 2
lb = (widin - la) / 2
p3 = pya.DPoint((p2.x * (la + lb) + p5.x * lb) / widin,
(p2.y * (la + lb) + p5.y * lb) / widin)
p4 = pya.DPoint((p2.x * lb + p5.x * (la + lb)) / widin,
(p2.y * lb + p5.y * (la + lb)) / widin)
return dict(p1=p1, p2=p2, p3=p3, p4=p4, p5=p5, p6=p6, la=la, lb=lb)
def produce_impl(self):
# This is the main part of the implementation: create the layout
# fetch the parameters
dbu = self.layout.dbu;
ly = self.layout
shapes = self.cell.shapes
theta=arcsin(0.5*self.yspan/self.radius)*180/pi+self.theta_ext
rad=self.radius*cos(theta*pi/180)
n_periods=int(ceil(self.target_length/self.pitch))
print("n_periods "+str(n_periods))
etch_width=self.pitch*(1-self.duty_cycle)
# for each grating ridge
for i in range(1,n_periods):
pts=[]
# create the points for the inside of the grating
# inner radius of the ridge
rad_inner=rad+self.pitch*(i-1)+etch_width
# outer radius of the ridge
rad_outer=rad+self.pitch*i
# do the top part of the inner arc
for i in range(0,self.n):
pts.append(pya.Point.from_dpoint(pya.DPoint(rad_inner*cos(theta*pi/180*(self.n-i)/self.n)/dbu,(rad_inner*sin(theta*pi/180*(self.n-i)/self.n)/dbu))))
# bottom part of inner arc
for i in range(0,self.n):
pts.append(pya.Point.from_dpoint(pya.DPoint(rad_inner*cos(theta*pi/180*i/self.n)/dbu,-rad_inner*sin(theta*pi/180*i/self.n)/dbu)))
# bottom part of outer arc
for i in range(0,self.n):
pts.append(pya.Point.from_dpoint(pya.DPoint(rad_outer*cos(theta*pi/180*(self.n-i)/self.n)/dbu,-rad_outer*sin(theta*pi/180*(self.n-i)/self.n)/dbu)))
#top part of outer arc
for i in range(0,self.n):
pts.append(pya.Point.from_dpoint(pya.DPoint(rad_outer*cos(theta*pi/180*i/self.n)/dbu,rad_outer*sin(theta*pi/180*i/self.n)/dbu)))
ridge=pya.Polygon(pts)
self.cell.shapes(self.l_layer).insert(ridge)
def _pts_path_selected():
for obj in IO.layout_view.each_object_selected():
#只检查第一个选中的对象
shape=obj.shape
if not shape.is_path():break
spts=[pya.DPoint(pt.x,pt.y) for pt in shape.path.each_point()]
return spts
IO.warning.warning("paintlib.Interactive.link", "Please select a Path", pya.MessageBox.Ok)
return []
def arc_NewtonInterpolation(n,r1):#(n,r1,r2):
thetax=0.53977;
thetay=-thetax*tan(pi/180*67.5)
X=[-1,-1,-1,-thetax,0,thetax,1,1,1]
Y=[-1,-1,-1,thetay,-sqrt(2),thetay,-1,-1,-1]
high=[-1,-1,1,1, 0,0]
f=BasicPainter.NewtonInterpolation(X,Y,high)
pts1=[pya.DPoint((-1.0+2.0/(n-1)*i)/sqrt(2)*r1,f(-1.0+2.0/(n-1)*i)/sqrt(2)*r1) for i in range(n)]
return pts1
def origin_ex_ey(self, params=None, multiple_of_90=False): # pylint: disable=unused-argument
cp = self.parse_param_args(params)
origin = pya.DPoint(0, 0)
if multiple_of_90:
if cp.angle_ex % 90 != 0:
raise RuntimeError("Specify an angle multiple of 90 degrees")
ex = rotate(EX, cp.angle_ex * pi / 180)
ey = rotate90(ex)
return origin, ex, ey
def constructors1(self,
pointc=pya.DPoint(0, 8000),
angle=0,
widout=20000,
widin=10000,
bgn_ext=0,
end_ext=0):
self.__init__(CavityBrush(pointc, angle, widout, widin, bgn_ext),
end_ext)
def box_dpolygon(point1, point3, ex=None):
# position point2 to the right of point1
if ex is None:
ex = pya.DPoint(1, 0)
ey = rotate90(ex)
point2 = point1 * ex * ex + point3 * ey * ey
point4 = point3 * ex * ex + point1 * ey * ey
return pya.DPolygon([point1, point2, point3, point4])
def test_1_Trans(self):
a = pya.Trans()
b = pya.Trans( pya.Trans.M135, pya.Point( 17, 5 ))
c = pya.Trans( 3, True, pya.Point( 17, 5 ))
d = pya.Trans( pya.Point( 17, 5 ))
e = pya.Trans( pya.Trans.M135 )
e2 = pya.Trans.from_dtrans( pya.DTrans.M135 )
f = pya.Trans( pya.DTrans( pya.DTrans.M135, pya.DPoint( 17, 5 )) )
self.assertEqual( str(a), "r0 0,0" )
self.assertEqual( str(pya.Trans.from_s(str(a))), str(a) )
self.assertEqual( str(b), "m135 17,5" )
self.assertEqual( str(c), "m135 17,5" )
self.assertEqual( str(d), "r0 17,5" )
self.assertEqual( str(e), "m135 0,0" )
self.assertEqual( str(e2), "m135 0,0" )
self.assertEqual( str(f), "m135 17,5" )
self.assertEqual( str(pya.Trans.from_s(str(f))), str(f) )
self.assertEqual( str(b.trans( pya.Point( 1, 0 ))), "17,4" )
self.assertEqual( a == b, False )
self.assertEqual( a == a, True )
self.assertEqual( a != b, True )
self.assertEqual( a != a, False )
self.assertEqual( (d * e) == b, True )
self.assertEqual( (e * d) == b, False )
i = c.inverted()
self.assertEqual( str(i), "m135 5,17" )
self.assertEqual( (i * b) == a, True )
self.assertEqual( (b * i) == a, True )
c = pya.Trans( 3, True, pya.Point( 17, 5 ))
self.assertEqual( str(c), "m135 17,5" )
c.disp = pya.Point(1, 7)
self.assertEqual( str(c), "m135 1,7" )
c.angle = 1
self.assertEqual( str(c), "m45 1,7" )
c.rot = 3
self.assertEqual( str(c), "r270 1,7" )
c.mirror = True
self.assertEqual( str(c), "m135 1,7" )
self.assertEqual( str(e.trans( pya.Edge(0, 1, 2, 3) )), "(-3,-2;-1,0)" )
self.assertEqual( str(( e * pya.Edge(0, 1, 2, 3) )), "(-3,-2;-1,0)" )
self.assertEqual( str(e.trans( pya.Box(0, 1, 2, 3) )), "(-3,-2;-1,0)" )
self.assertEqual( str(( e * pya.Box(0, 1, 2, 3) )), "(-3,-2;-1,0)" )
self.assertEqual( str(e.trans( pya.Text("text", pya.Vector(0, 1)) )), "('text',m135 -1,0)" )
self.assertEqual( str(( e * pya.Text("text", pya.Vector(0, 1)) )), "('text',m135 -1,0)" )
self.assertEqual( str(e.trans( pya.Polygon( [ pya.Point(0, 1), pya.Point(2, -3), pya.Point(4, 5) ] ) )), "(-5,-4;-1,0;3,-2)" )
self.assertEqual( str(( e * pya.Polygon( [ pya.Point(0, 1), pya.Point(2, -3), pya.Point(4, 5) ] ) )), "(-5,-4;-1,0;3,-2)" )
self.assertEqual( str(e.trans( pya.Path( [ pya.Point(0, 1), pya.Point(2, 3) ], 10 ) )), "(-1,0;-3,-2) w=10 bx=0 ex=0 r=false" )
self.assertEqual( str(( e * pya.Path( [ pya.Point(0, 1), pya.Point(2, 3) ], 10 ) )), "(-1,0;-3,-2) w=10 bx=0 ex=0 r=false" )
def constructors1(self,
pointc=pya.DPoint(0, 0),
angle=0,
widout=20000,
widin=10000,
bgn_ext=0):
tr = pya.DCplxTrans(1, angle, False, pointc)
self.edgeout = pya.DEdge(0, widout / 2, 0, -widout / 2).transformed(tr)
self.edgein = pya.DEdge(bgn_ext, widin / 2, bgn_ext,
-widin / 2).transformed(tr)
def arc(point0, r, n, angle0, angle1):
angles = [
angle0 + 1.0 * x / (n - 1) * (angle1 - angle0) for x in range(n)
]
arcpointlist = [
pya.DPoint(point0.x + r * cos(angle * pi / 180),
point0.y + r * sin(angle * pi / 180))
for angle in angles
]
return arcpointlist
def _get_nearest_brush(x, y):
bestbrush = None
bestr = Interactive.searchr
pt = pya.DPoint(x, y)
for brush in Interactive.brushlist:
r = brush.edgein.p1.distance(pt)
if r < bestr:
bestr = r
bestbrush = brush
return bestbrush
def TurningInterpolation(self,radius):
#radius非负向右，负是向左
angle=90
delta=self.pointr.distance(self.pointl)
dx=(self.pointr.x-self.pointl.x)/delta
dy=(self.pointr.y-self.pointl.y)/delta
dtheta=atan2(dy,dx)*180/pi
centerx=self.pointr.x+(radius-delta/2)*dx
centery=self.pointr.y+(radius-delta/2)*dy
n=ceil(1.3*(abs(radius)+delta/2)*angle*pi/180/self.pointdistance)+2
if True:
rsgn=(radius>0)-(radius<0)
pointr2=pya.DPoint(centerx-rsgn*(radius-delta/2)*dy,centery+rsgn*(radius-delta/2)*dx)
pointl2=pya.DPoint(centerx-rsgn*(radius+delta/2)*dy,centery+rsgn*(radius+delta/2)*dx)
arc1=BasicPainter.arc_NewtonInterpolation(n,abs(radius)+delta/2,abs(radius)-delta/2)
arc2=(BasicPainter.trans(arc1,(-180-dtheta-45*rsgn))).moved(centerx,centery)
self.outputlist.append(arc2)
self.pointr=pointr2
self.pointl=pointl2
def translate_from_center(self, offset):
from math import pi, cos, sin, acos, sqrt
from .utils import angle_vector
pts = [pt for pt in self.get_dpoints()]
tpts = [pt for pt in self.get_dpoints()]
for i in range(0, len(pts)):
if i == 0:
u = pts[i] - pts[i + 1]
v = -u
elif i == (len(pts) - 1):
u = pts[i - 1] - pts[i]
v = -u
else:
u = pts[i - 1] - pts[i]
v = pts[i + 1] - pts[i]
if offset < 0:
o1 = pya.DPoint(abs(offset) * cos(angle_vector(u) * pi / 180 - pi / 2),
abs(offset) * sin(angle_vector(u) * pi / 180 - pi / 2))
o2 = pya.DPoint(abs(offset) * cos(angle_vector(v) * pi / 180 + pi / 2),
abs(offset) * sin(angle_vector(v) * pi / 180 + pi / 2))
else:
o1 = pya.DPoint(abs(offset) * cos(angle_vector(u) * pi / 180 + pi / 2),
abs(offset) * sin(angle_vector(u) * pi / 180 + pi / 2))
o2 = pya.DPoint(abs(offset) * cos(angle_vector(v) * pi / 180 - pi / 2),
abs(offset) * sin(angle_vector(v) * pi / 180 - pi / 2))
p1 = u + o1
p2 = o1
p3 = v + o2
p4 = o2
d = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x)
if round(d, 10) == 0:
tpts[i] += p2
else:
tpts[i] += pya.DPoint(((p1.x * p2.y - p1.y * p2.x) * (p3.x - p4.x) - (p1.x - p2.x) * (p3.x * p4.y - p3.y * p4.x)) / d,
((p1.x * p2.y - p1.y * p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x * p4.y - p3.y * p4.x)) / d)
if self.__class__ == pya.Path:
return pya.Path([pya.Point(pt.x, pt.y) for pt in tpts], self.width)
elif self.__class__ == pya.DPath:
return pya.DPath(tpts, self.width)
def Turning(self, radius, angle=90):
#radius正是向右，负是向左,不能为0
delta = self.pointr.distance(self.pointl)
dx = (self.pointr.x - self.pointl.x) / delta
dy = (self.pointr.y - self.pointl.y) / delta
centerx = self.pointr.x + (radius - delta / 2) * dx
centery = self.pointr.y + (radius - delta / 2) * dy
if angle == 90:
#
rsgn = (radius > 0) - (radius < 0)
pointr2 = pya.DPoint(centerx - rsgn * (radius - delta / 2) * dy,
centery + rsgn * (radius - delta / 2) * dx)
pointl2 = pya.DPoint(centerx - rsgn * (radius + delta / 2) * dy,
centery + rsgn * (radius + delta / 2) * dx)
self.outputlist.append(
pya.DPolygon([self.pointr, self.pointl, pointl2, pointr2]))
self.pointr = pointr2
self.pointl = pointl2
else:
pass
def __setstate__(self, state):
self.name = state['name']
x, y = state['position']
self.position = pya.DPoint(x, y)
direction = state['direction']
if isinstance(direction, tuple):
x, y = direction
self.direction = pya.DVector(x, y)
else:
self.direction = direction
self.width = state['width']
def __init__(self):
# Important: initialize the super class
super(Star, self).__init__()
# declare the parameters
self.param("l", self.TypeLayer, "Layer", default=pya.LayerInfo(1, 0))
self.param("hi", self.TypeShape, "", default=pya.DPoint(5, 0))
self.param("ho", self.TypeShape, "", default=pya.DPoint(10, 0))
self.param("ri", self.TypeDouble, "Inner radius", default=5)
self.param("ro", self.TypeDouble, "Outer radius", default=10)
self.param("n", self.TypeInt, "Number of corners", default=8)
self.param("ri_",
self.TypeDouble,
"Inner radius",
default=5,
hidden=True)
self.param("ro_",
self.TypeDouble,
"Outer radius",
default=10,
hidden=True)
def coerce_parameters_impl(self):
if self.n < 3:
self.n = 3
if self.ri < 0:
self.ri *= -1
if self.ro < 0:
self.ro *= -1
if self.ri_ != self.ri or self.ro_ != self.ro:
# update handle
self.hi = pya.DPoint(self.ri, 0)
self.ho = pya.DPoint(self.ro, 0)
# fix params
self.ri_ = self.ri
self.ro_ = self.ro
else:
# calc params from handle
self.ri = self.ri_ = math.sqrt(
abs(self.hi.x)**2 + abs(self.hi.y)**2)
self.ro = self.ro_ = math.sqrt(
abs(self.ho.x)**2 + abs(self.ho.y)**2)
def __init__(self):
# Important: initialize the super class
super(CrossPads, self).__init__()
# declare the parameters
self.param("l", self.TypeLayer, "Layer", default=pya.LayerInfo(1, 0))
self.param("cp", self.TypeShape, "", default=pya.DPoint(10, 0.5))
self.param("pp", self.TypeShape, "", default=pya.DPoint(20, 1))
self.param("bp", self.TypeShape, "", default=pya.DPoint(20, 20))
self.param("cl", self.TypeDouble, "Cross length", default=10)
self.param("pl", self.TypeDouble, "Pad length", default=10)
self.param("cw", self.TypeDouble, "Cross width", default=1)
self.param("pw", self.TypeDouble, "Pad width", default=2)
self.param("inv", self.TypeBoolean, "Inverted", default=False)
self.param("b1", self.TypeDouble, "Boundary width", default=20)
self.param("b2", self.TypeDouble, "Boundary height", default=20)
self.param("cl_",
self.TypeDouble,
"Cross length",
default=10,
hidden=True)
self.param("pl_",
self.TypeDouble,
"Pad length",
default=10,
hidden=True)
self.param("cw_",
self.TypeDouble,
"Cross width",
default=1,
hidden=True)
self.param("pw_", self.TypeDouble, "Pad width", default=2, hidden=True)
self.param("b1_",
self.TypeDouble,
"Boundary width",
default=20,
hidden=True)
self.param("b2_",
self.TypeDouble,
"Boundary height",
default=20,
hidden=True)
