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)