def render(self, text, antialias, color, background=None): """ Render text onto surface. Arguments: text to render (string) antialias of text (bool) color of text (R,G,B) background color (R,G,B) """ w, h = self.size(text) surf = surface.Surface((w, h), BufferedImage.TYPE_INT_ARGB) g2d = surf.createGraphics() if background: g2d.setColor(Color(background)) #0.23 g2d.fillRect(0, 0, w, h) g2d.setFont(self.font) if antialias: g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON) g2d.setColor(Color(color)) #0.23 g2d.drawString(text, 0, (h // 2) + (self.fontMetrics.getAscent() // 2)) #0.22 if self.underline: g2d.setStroke(BasicStroke(1)) g2d.drawLine(0, h - 1, w - 1, h - 1) #0.22 g2d.dispose() return surf
def render(self, text, antialias, color, background=None): """ Render text onto surface. Arguments: text to render (string) antialias of text (bool) color of text (R,G,B) background color (R,G,B) """ w,h = self.size(text) surf = surface.Surface((w,h), BufferedImage.TYPE_INT_ARGB) g2d = surf.createGraphics() if background: R,G,B = background g2d.setColor(Color(R,G,B)) g2d.fillRect(0,0,w,h) g2d.setFont(self.font) if antialias: g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON) R,G,B = color g2d.setColor(Color(R,G,B)) g2d.drawString(text,2,h//1.25+2) if self.underline: g2d.setStroke(BasicStroke(1)) g2d.drawLine(2,h-4,w-3,h-4) g2d.dispose() return surf
def __init__(self): window.Window.__init__(self) #f = fontsurface.FontSurface() #self.add_surface(f) self.s = surface.Surface('s') (self.x, self.y, self.z) = 100, 100, 0 self.s.set_location(self.x, self.y, self.z) self.s.set_back_color(255, 0, 0) #s2 = surface.Surface('s2') #s2.set_back_color(255,255,0) #s2.set_location(100,100,0) #s3 = surface.Surface('s3') #s3.set_back_color(255,0,255) #s3.set_location(100,100,0) #self.s.add_surface(s2) #s2.add_surface(s3) self.add_surface(self.s) #self.t = surface.Surface('s') #self.add_surface(self.t) #self.t.set_location(self.x,self.y + 300,self.z) self.is_d = False
def main(argv): Deltas = np.arange(1, 21, 1) sim_time = [] for DELTA_X in Deltas: sim_start_time = clock() # check if config is given as parameter if len(sys.argv) < 2: usage() exit() par.LoadConfig(sys.argv[1]) dtime = par.TIME_STEP dt = dtime time = 0 end_time = par.TOTAL_TIME surface_start = sf.Surface(par.XMAX, par.XMIN, DELTA_X) surface = sf.Surface(par.XMAX, par.XMIN, DELTA_X) while time < end_time: ad.advance(surface, dt) surface.write(time, surface.x.size, end_time, dtime) time, dt = ad.timestep(dtime, time, end_time) surface.write(time, surface.x.size, end_time, dtime) sim_end_time = clock() print("Execution time:" + str(sim_end_time - sim_start_time) + "s") sim_time.append(sim_end_time - sim_start_time) plt.plot(Deltas, np.array(sim_time)) plt.ylabel('Simulationtime in s') plt.xlabel('DELTA_X') plt.show() sim_time_table = np.column_stack((Deltas, np.array(sim_time))) sim_time_table.tofile('timing.dat', sep=',', format='%s') if par.PLOT_SURFACE: surface_start.plot(end_time, dtime, 'OF Start', '-+r') surface.plot(end_time, dtime, 'OF Stop', '-+b')
def init(): """ **pyj2d.font.init** Initialize font module. """ global _surf, _g2d, _initialized, match_font _surf = surface.Surface((1, 1), BufferedImage.TYPE_INT_RGB) _g2d = _surf.createGraphics() match_font = lambda *arg: None #nonimplemented_methods _initialized = True
def refresh_paraxial(self): self.EFL = first_order_tools.EFL(self, 0, 0) self.EPD = self.EFL / self.FNO self.EP_thickness = first_order_tools.EP(self) self.object_position = -1000000 # temporary only for infinity conjugate start = 2 end = len(self.surface_list) OAL = first_order_tools.OAL(self, start, end) Pos_z = OAL * 0.2 # entrance pupil fake surface use as surface 1 self.surface_list[0] = surface.Surface(wavelength_list = self.wavelength_list,number=1,\ radius=10000000,thickness=Pos_z,glass='air',STO=False,\ __diameter__=0)
def simulation(path_to_cfg, path_to_srf=None): """Main Method to Simulate the etching process. :param path_to_cfg: path to the config file """ par.initPar(path_to_cfg) init_sputtering() #Define Parameters surface = srf.Surface() time = 0 # Path for Surface file = Path of Config file file_name = path_to_cfg.replace(".cfg", ".srf") # Create .srf file and write down initialization Surface surface.write(time, file_name, 'w') # Simulate Etching process until Max. Time is reached while time < par.TOTAL_TIME: adv.advance(surface) dt = adv.timestep(time) time += dt surface.write(time, file_name, 'a') # Stop the timer t_2 = timer() # Print out the computation time of the program print(t_2 - t_1) # Check if surface was already saved filelist = os.listdir() search_strg = file_name + '_save' is_saved = False for i in range(len(filelist)): if filelist[i] == search_strg: is_saved = True saved_file = str(filelist[i].split('.')[0]) + '.srf' # Plot the Surface # If the file was already saved print both original and saved file # in one plot if par.PLOT_SURFACE: if is_saved: plot.plot(file_name, saved_file) else: plot.plot(file_name) return surface
def self_affine(saparams, power_of_two, seed=None): np.random.seed(seed) lambda_L_over_lambda_0 = 1 if saparams.lambda_L_over_lambda_0 is None else saparams.lambda_L_over_lambda_0 lambda_L_over_lambda_1 = sys.maxsize if saparams.lambda_L_over_lambda_1 is None else saparams.lambda_L_over_lambda_1 N, L = 2**power_of_two, saparams.dimensions[0] power = -(saparams.hurst + 1.0) f_L = 1.0 / N # rel frequency f_0, f_1 = f_L * lambda_L_over_lambda_0, f_L * lambda_L_over_lambda_1 A = np.zeros((N, N), dtype=complex) center = int(N / 2) rand_norm_1, rand_norm_2 = np.random.randn(center + 1, center + 1), np.random.randn( center + 1, center + 1) rand_unif_1, rand_unif_2 = np.random.rand(center + 1, center + 1), np.random.rand( center + 1, center + 1) for i in range(0, int(N / 2 + 1)): for j in range(0, int(N / 2 + 1)): phase = 2.0 * np.pi * rand_unif_1[i, j] rad = 0.0 f = np.sqrt((float(i) / N)**2 + (float(j) / N)**2) if i != 0 or j != 0: f = f if f > f_0 else f_0 # hi pass --> f_0 rad = rand_norm_1[i, j] * f**power if f > f_1: # lo pass --> f_1 rad, phase = 0.0, 0.0 # print "f = ", f, "rad = ", rad A[i, j] = rad * np.cos(phase) + rad * np.sin(phase) * 1j i0 = 0 if i == 0 else N - i j0 = 0 if j == 0 else N - j A[i0, j0] = rad * np.cos(phase) - rad * np.sin(phase) * 1j A[center, 0] = A[center, 0].real + 0j A[0, center] = A[0, center].real + 0j A[center, center] = A[center, center].real + 0j for i in range(1, center): for j in range(1, center): phase = 2.0 * np.pi * rand_unif_2[i, j] f = np.sqrt((float(i) / N)**2 + (float(j) / N)**2) f = f if f > f_0 else f_0 # hi pass --> f_0 rad = rand_norm_2[i, j] * f**power if f > f_1: # lo pass --> f_1 rad, phase = 0., 0. A[i, N - j] = rad * np.cos(phase) + rad * np.sin(phase) * 1j A[N - i, j] = rad * np.cos(phase) - rad * np.sin(phase) * 1j H = np.real(np.fft.ifft2((A))) s = bs.Surface(H, L / float(N)) s = bs.scale_to_rms(s, saparams.hrms) s = bs.shift_to_zero_mean(s) return s
def parse(self): super(ParameterData128, self).parse() n, m, p, q = [int(p) for p in self.params[1:5]] U = self.params[10:10 + n + p + 2] V = self.params[10 + n + p + 2:10 + n + m + p + q + 4] w = self.params[10 + n + m + p + q + 4:10 + n + m + p + q + 4 + (n + 1) * (m + 1)] P = self.params[10 + n + m + p + q + 4 + (n + 1) * (m + 1):-4] w = np.resize(w, (m + 1, n + 1, 1)) w = w.transpose((1, 0, 2)) P = np.resize(P, (m + 1, n + 1, 3)) P = P.transpose((1, 0, 2)) P *= w Pw = np.concatenate((P, w), axis=2) s = surface.Surface(surface.ControlNet(Pw=Pw), (p, q), (U, V)) objs.append(s)
def sphere(N, edge_length, radius, scaling=1.0): """ Creates a 2D Hertzian contact domain, a half sphere embedded in a plane. >>> r = 1.0 >>> s = sphere(100, 1., r) >>> np.isclose(np.max(s.h), r, rtol=1.0E-4) True """ x = np.linspace(-edge_length / 2.0, edge_length / 2.0, N) XX, YY = np.meshgrid(x, x) r = np.sqrt(XX * XX + YY * YY) h = np.zeros(r.shape) h[r <= radius] = np.sqrt(radius**2 - r[r <= radius]**2) * scaling dxy = edge_length / float(N) s = bs.Surface(h, dxy) return s
pass else: m = m + 1 number = m radius = i[1] thickness = i[2] if i[3] == '': index = 0 else: index = 1.5 STO = False if len(i) == 5: STO = True s = surface.Surface(number = number, radius = radius, thickness = i[2], index = index, STO = STO) Surface_list.append(s) for j in range(len(Surface_list)): print Surface_list[j].number,' ',Surface_list[j].radius,' ',Surface_list[j].thickness,Surface_list[j].STO
# define rays l1 = np.linspace(-5, 5, 10) Pos1 = [] for i in l1: for j in l1: if i**2 + j**2 < 25: Pos1.append([i, j, 0]) KLM = [] for i in Pos1: KLM.append([0, 0, 1]) # define surface surface1 = surface.Surface(number=1, radius=10000000, thickness=10, index=1, STO=0) #object surface2 = surface.Surface(number=2, radius=20, thickness=40, index=2, STO=0) #surface i surface3 = surface.Surface(number=3, radius=10000000, thickness=0, index=1, STO=0) #image raylist1 = [] raylist2 = [] for pos, klm in zip(Pos1, KLM): ray1 = field.Field(Pos=pos, KLM=klm)
def addSurface(self): # add a shape surface s = surface.Surface() self.verticalLayout.addWidget(s) return s
def extract(self, u, di): ''' Extract an isoparametric Surface from the Volume. Parameters ---------- u = the parameter value at which to extract the Surface di = the parametric direction in which to extract the Surface (0, 1 or 2) Returns ------- Surface = the extracted Surface ''' n, p, U, m, q, V, l, r, W, Pw = self.var() u = knot.clean_knot(u) if di == 0: if u == U[0]: Pwc = Pw[0, :, :] elif u == U[-1]: Pwc = Pw[-1, :, :] else: k, s = basis.find_span_mult(n, p, U, u) rr = p - s if rr > 0: U, V, W, Pw = \ volume_knot_ins(n, p, U, m, q, V, l, r, W, Pw, u, k, s, rr, 0) Pwc = Pw[k - s, :, :] p, q = q, r U, V = V, W elif di == 1: if u == V[0]: Pwc = Pw[:, 0, :] elif u == V[-1]: Pwc = Pw[:, -1, :] else: k, s = basis.find_span_mult(m, q, V, u) rr = q - s if rr > 0: U, V, W, Pw = \ volume_knot_ins(n, p, U, m, q, V, l, r, W, Pw, u, k, s, rr, 1) Pwc = Pw[:, k - s, :] Pwc = np.transpose(Pwc, (1, 0, 2)) p, q = r, p U, V = W, U elif di == 2: if u == W[0]: Pwc = Pw[:, :, 0] elif u == W[-1]: Pwc = Pw[:, :, -1] else: k, s = basis.find_span_mult(l, r, W, u) rr = r - s if rr > 0: U, V, W, Pw = \ volume_knot_ins(n, p, U, m, q, V, l, r, W, Pw, u, k, s, rr, 2) Pwc = Pw[:, :, k - s] return surface.Surface(surface.ControlNet(Pw=Pwc), (p, q), (U, V))
def main(): surfaceobj = surface.Surface(filename, 5, 5, 5, 5) rectobj = surfaceobj.getRect() print(rectobj)