def circulos(foto,actual,centro,cont,color): print "------------------------------" x1,y1=actual # inicio x2,y2=centro #centro print x1 print x2 print "punto de inicio:"+str(actual) print "Centro:"+str(centro) area=cont print "Area de figura en revision:"+str(area) radio=math.sqrt((x2-x1)**2+(y2-y1)**2) print radio final = radio*2 #diametro print "Radio de posible circulo:"+str(radio) comprobar_area=(pi*(radio**2)) print "Area de posible circulo:"+str(comprobar_area) if(comprobar_area-500)<area<(comprobar_area+500): print "La figura es un circulo" return color, actual,centro, diametro else: print "Esta figura no es un circulo" draw= ImageDraw(image) draw.ellipse((actual-1,final+1),outline = "black") foto.save("putitos.jpg")
def filterUnreachable(self, reachable): # we'll use the flood fill in Image img = Image.fromarray(N.uint8(self._raster) * 64).copy() ImageDraw.floodfill(img,map(int,reachable[:2]), 128) n = N.array(img.getdata()).reshape(img.size[0], img.size[1]) self._raster = N.piecewise(n, [n==128,n!=128], [0,1])
def make_brasil_map(data, finalsize=None): brasil_png = os.path.join(os.path.split(__file__)[0], 'brasil.png') raw = Image.open(brasil_png).copy() mapa = Image.new('RGBA', raw.size, 'white') mapa.paste(raw, (0, 0)) for k in data: if k in places: if type(data[k]) == str: color = ImageColor.getcolor('#'+data[k], 'RGBA') else: color = data[k] ImageDraw.floodfill(mapa, places[k], color) if finalsize: mapa = mapa.resize(finalsize) dump = StringIO.StringIO() mapa.save(dump, 'PNG') return dump.getvalue()
def drawterritory(t, shaded): """Draw an entire territory (possibly shaded)""" risknetwork.draw_territory(t, shaded) terr = territories[t.name] #Create colored version of the image canvas.delete(terr.name) #print 'Drawing territory: ', t.name if hasattr(t.player, 'backcolor'): for fp in terr.floodpoints: #print 'Flood-filling', terr.name, ' territory' ImageDraw.floodfill(terr.photo, fp, hex_to_rgb(t.player.backcolor)) #print 'Saving images' terr.shadedimage = ImageTk.PhotoImage(terr.photo.point(lambda x:x * 0)) terr.currentimage = ImageTk.PhotoImage(terr.photo) if shaded: canvas.create_image(terr.x, terr.y, anchor=Tkinter.NW, image=terr.shadedimage, tags=(terr.name,)) else: canvas.create_image(terr.x, terr.y, anchor=Tkinter.NW, image=terr.currentimage, tags=(terr.name,)) drawarmy(riskengine.territories[terr.name], 1)
def run(self, callback): self.callback = callback #try: import ImageDraw, Image, os s = self.job.project.menutemplate.settings s_top = s.margin_top.getValue() s_bottom = s.margin_bottom.getValue() s_left = s.margin_left.getValue() s_right = s.margin_right.getValue() s_rows = s.space_rows.getValue() s_cols = s.space_cols.getValue() nr_cols = s.cols.getValue() nr_rows = s.rows.getValue() thumb_size = s.thumb_size.getValue() if thumb_size[0]: from Image import open as Image_open (s_width, s_height) = s.dimensions.getValue() fonts = self.Menus.fonts im_bg = self.Menus.im_bg_orig.copy() im_high = Image.new("P", (s_width, s_height), 0) im_high.putpalette(self.Menus.spu_palette) draw_bg = ImageDraw.Draw(im_bg) draw_high = ImageDraw.Draw(im_high) if self.menu_count == 1: headlineText = self.job.project.settings.name.getValue().decode("utf-8") headlinePos = self.getPosition(s.offset_headline.getValue(), 0, 0, s_width, s_top, draw_bg.textsize(headlineText, font=fonts[0])) draw_bg.text(headlinePos, headlineText, fill=self.Menus.color_headline, font=fonts[0]) spuxml = """<?xml version="1.0" encoding="utf-8"?> <subpictures> <stream> <spu highlight="%s" transparent="%02x%02x%02x" start="00:00:00.00" force="yes" >""" % (self.highlightpngfilename, self.Menus.spu_palette[0], self.Menus.spu_palette[1], self.Menus.spu_palette[2]) #rowheight = (self.Menus.fontsizes[1]+self.Menus.fontsizes[2]+thumb_size[1]+s_rows) menu_start_title = (self.menu_count-1)*self.job.titles_per_menu + 1 menu_end_title = (self.menu_count)*self.job.titles_per_menu + 1 nr_titles = len(self.job.project.titles) if menu_end_title > nr_titles: menu_end_title = nr_titles+1 col = 1 row = 1 for title_no in range( menu_start_title , menu_end_title ): title = self.job.project.titles[title_no-1] col_width = ( s_width - s_left - s_right ) / nr_cols row_height = ( s_height - s_top - s_bottom ) / nr_rows left = s_left + ( (col-1) * col_width ) + s_cols/2 right = left + col_width - s_cols top = s_top + ( (row-1) * row_height) + s_rows/2 bottom = top + row_height - s_rows width = right - left height = bottom - top if bottom > s_height: bottom = s_height #draw_bg.rectangle((left, top, right, bottom), outline=(255,0,0)) im_cell_bg = Image.new("RGBA", (width, height),(0,0,0,0)) draw_cell_bg = ImageDraw.Draw(im_cell_bg) im_cell_high = Image.new("P", (width, height), 0) im_cell_high.putpalette(self.Menus.spu_palette) draw_cell_high = ImageDraw.Draw(im_cell_high) if thumb_size[0]: thumbPos = self.getPosition(s.offset_thumb.getValue(), 0, 0, width, height, thumb_size) box = (thumbPos[0], thumbPos[1], thumbPos[0]+thumb_size[0], thumbPos[1]+thumb_size[1]) try: thumbIm = Image_open(title.inputfile.rsplit('.',1)[0] + ".png") im_cell_bg.paste(thumbIm,thumbPos) except: draw_cell_bg.rectangle(box, fill=(64,127,127,127)) border = s.thumb_border.getValue() if border: draw_cell_high.rectangle(box, fill=1) draw_cell_high.rectangle((box[0]+border, box[1]+border, box[2]-border, box[3]-border), fill=0) titleText = title.formatDVDmenuText(s.titleformat.getValue(), title_no).decode("utf-8") titlePos = self.getPosition(s.offset_title.getValue(), 0, 0, width, height, draw_bg.textsize(titleText, font=fonts[1])) draw_cell_bg.text(titlePos, titleText, fill=self.Menus.color_button, font=fonts[1]) draw_cell_high.text(titlePos, titleText, fill=1, font=self.Menus.fonts[1]) subtitleText = title.formatDVDmenuText(s.subtitleformat.getValue(), title_no).decode("utf-8") subtitlePos = self.getPosition(s.offset_subtitle.getValue(), 0, 0, width, height, draw_cell_bg.textsize(subtitleText, font=fonts[2])) draw_cell_bg.text(subtitlePos, subtitleText, fill=self.Menus.color_button, font=fonts[2]) del draw_cell_bg del draw_cell_high im_bg.paste(im_cell_bg,(left, top, right, bottom), mask=im_cell_bg) im_high.paste(im_cell_high,(left, top, right, bottom)) spuxml += """ <button name="button%s" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (str(title_no).zfill(2),left,right,top,bottom ) if col < nr_cols: col += 1 else: col = 1 row += 1 top = s_height - s_bottom - s_rows/2 if self.menu_count < self.job.nr_menus: next_page_text = s.next_page_text.getValue().decode("utf-8") textsize = draw_bg.textsize(next_page_text, font=fonts[1]) pos = ( s_width-textsize[0]-s_right, top ) draw_bg.text(pos, next_page_text, fill=self.Menus.color_button, font=fonts[1]) draw_high.text(pos, next_page_text, fill=1, font=fonts[1]) spuxml += """ <button name="button_next" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (pos[0],pos[0]+textsize[0],pos[1],pos[1]+textsize[1]) if self.menu_count > 1: prev_page_text = s.prev_page_text.getValue().decode("utf-8") textsize = draw_bg.textsize(prev_page_text, font=fonts[1]) pos = ( (s_left+s_cols/2), top ) draw_bg.text(pos, prev_page_text, fill=self.Menus.color_button, font=fonts[1]) draw_high.text(pos, prev_page_text, fill=1, font=fonts[1]) spuxml += """ <button name="button_prev" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (pos[0],pos[0]+textsize[0],pos[1],pos[1]+textsize[1]) del draw_bg del draw_high fd=open(self.menubgpngfilename,"w") im_bg.save(fd,"PNG") fd.close() fd=open(self.highlightpngfilename,"w") im_high.save(fd,"PNG") fd.close() spuxml += """ </spu> </stream> </subpictures>""" f = open(self.spuxmlfilename, "w") f.write(spuxml) f.close() Task.processFinished(self, 0)
def callback(msg_1): global i global j #global ini global xcgg global lcg, lhg global vel_res, wvel_res #linear velocity, and angular velocity global img_nn_c global out_gonet global vres, wres global xc, yc, xyoffset j = j + 1 if j == 1: xkg = xcgg #previous image xd = np.zeros((3, 3, 128, 128), dtype=np.float32) # resize and crop image for msg_1 cv2_msg_img = bridge.imgmsg_to_cv2(msg_1) cv_imgc = bridge.cv2_to_imgmsg(cv2_msg_img, 'rgb8') pil_img = encode(cv_imgc) fg_img = PILImage.new('RGBA', pil_img.size, (0, 0, 0, 255)) draw = ImageDraw.Draw(fg_img) draw.ellipse(XYc, fill=(0, 0, 0, 0)) pil_img.paste(fg_img, (0, 0), fg_img.split()[3]) img_msg = decode(pil_img) cv2_imgd = bridge.imgmsg_to_cv2(img_msg, 'rgb8') #crop the image cv_cutimg = cv2_imgd[yc - xyoffset:yc + xyoffset, xc - xyoffset:xc + xyoffset] cv_cutimg = cv2.transpose(cv_cutimg) cv_cutimg = cv2.flip(cv_cutimg, 1) #resize the image 3x128x128 cv_resize1 = cv2.resize(cv_cutimg, (rsizex, rsizey)) cv_resizex = cv_resize1.transpose(2, 0, 1) in_imgcc1 = np.array([cv_resizex], dtype=np.float32) #normalization in_img1 = (in_imgcc1 - 128) / 128 for i in range(batchsize): #usually batchsize=1 img_nn_c[i] = in_img1 vresc[i][0][0][0] = vel_res wresc[i][0][0][0] = wvel_res xcg = Variable(cuda.to_gpu(img_nn_c)) vrescg = Variable(cuda.to_gpu(vresc)) wrescg = Variable(cuda.to_gpu(wresc)) #designing the virtual velocity from joypad input vel_ref(linear velocity) and wvel_ref(angular velocity) vres[0][0][0] = 0.5 if wvel_ref == 0.0: wres[0][0][0] = 0.0 elif wvel_ref != 0.0 and vel_ref == 0.0: if wvel_ref > 0.0: wres[0][0][0] = 1.0 else: wres[0][0][0] = -1.0 elif vel_ref < 0.0: wres[0][0][0] = 0.0 else: rd = 2.5 * vel_ref / wvel_ref wres[0][0][0] = 0.5 / rd if wres[0][0][0] > 1.0: wres[0][0][0] = 1.0 elif wres[0][0][0] < -1.0: wres[0][0][0] = -1.0 vresg = Variable(cuda.to_gpu(vres)) #virtual linear velocity wresg = Variable(cuda.to_gpu(wres)) #virtual angular velocity fl.l_LSTM.h = Variable(lhg) #internal value of LSTM fl.l_LSTM.c = Variable(lcg) #internal value of LSTM with chainer.using_config('train', False), chainer.no_backprop_mode(): img_gen = gen(invg(xcg)) dis_real = dis(xcg) dis_gen = dis(img_gen) output = fl(xcg - img_gen, dis_real - dis_gen, dis_real) out_gonet[0] = np.reshape(cuda.to_cpu(output.data), (batchsize)) lhg = fl.l_LSTM.h.data lcg = fl.l_LSTM.c.data xcgg = xcg #keep current image for the next step font = ImageFont.truetype( "/usr/share/fonts/truetype/freefont/FreeMonoBold.ttf", 25) stext = 35 for k in range(4): # 4steps prediction if k == 0: xkg = xkg xcg = xcg else: xkg = xcg xcg = xap #future prediction:start with chainer.using_config('train', False), chainer.no_backprop_mode(): if k == 0: x = dec(enc(xkg), vrescg, wrescg) else: x = dec(enc(xkg), vresg, wresg) genk = F.spatial_transformer_sampler(xkg, x) xkp = genk with chainer.using_config('train', False), chainer.no_backprop_mode(): xcf = dec(enc(xcg), vresg, wresg) xkf = dec(enc(xkp), vresg, wresg) gencf = F.spatial_transformer_sampler(xcg, xcf) genkf = F.spatial_transformer_sampler(xkp, xkf) indata = F.concat((genkf, gencf), axis=1) maskg = Variable(cuda.to_gpu(mask_batch)) with chainer.using_config('train', False), chainer.no_backprop_mode(): zL = encD(indata) xfLs = decD(zL) xfL = F.separate(xfLs, axis=1) apf0 = F.reshape(xfL[0], (batchsize, 1, 128, 128)) apf1 = F.reshape(xfL[1], (batchsize, 1, 128, 128)) apf2 = F.reshape(xfL[2], (batchsize, 1, 128, 128)) apf3 = F.reshape(xfL[3], (batchsize, 1, 128, 128)) mask_kL = F.reshape(xfL[4], (batchsize, 1, 128, 128)) mask_cL = F.reshape(xfL[5], (batchsize, 1, 128, 128)) apfLc = F.concat((apf0, apf1), axis=1) apfLk = F.concat((apf2, apf3), axis=1) genLcx = F.spatial_transformer_sampler(gencf, apfLc + maskg) genLkx = F.spatial_transformer_sampler(genkf, apfLk + maskg) maskL = F.concat((mask_kL, mask_cL), axis=1) mask_softL = F.softmax(maskL, axis=1) mask_sepL = F.separate(mask_softL, axis=1) mask_knL = F.reshape(mask_sepL[0], (batchsize, 1, 128, 128)) mask_cnL = F.reshape(mask_sepL[1], (batchsize, 1, 128, 128)) xap = F.scale(genLcx, mask_cnL, axis=0) + F.scale( genLkx, mask_knL, axis=0) #predicted image #GONet with chainer.using_config('train', False), chainer.no_backprop_mode(): img_gen = gen(invg(xap)) dis_real = dis(xap) dis_gen = dis(img_gen) output = fl(xap - img_gen, dis_real - dis_gen, dis_real) out_gonet[k + 1] = np.reshape(cuda.to_cpu(output.data), (batchsize)) #showing predicted image and traversable probability by GONet out_imgc = img_nn_c imgb = np.fmin(255.0, np.fmax(0.0, out_imgc * 128 + 128)) imgc = np.reshape(imgb, (3, 128, 128)) imgd = imgc.transpose(1, 2, 0) imge = imgd.astype(np.uint8) imgm = bridge.cv2_to_imgmsg(imge) imgg = PILImage.new('RGB', (128, 30)) d = ImageDraw.Draw(imgg) d.text((stext, 0), str(np.round(out_gonet[0][0], 2)), fill=(int(255 * (1.0 - out_gonet[0][0])), int(255 * out_gonet[0][0]), 0), font=font) imgtext = decode(imgg) imgtextcv = bridge.imgmsg_to_cv2(imgtext, 'bgr8') imgtextcvx = imgtextcv.transpose(2, 0, 1) imgc = np.concatenate((imgc, imgtextcvx), axis=1) # imgcc0 = imgc for im in range(1): out_imgc = cuda.to_cpu(xap.data[im]) imgb = np.fmin(255.0, np.fmax(0.0, out_imgc * 128 + 128)) imgc = np.reshape(imgb, (3, 128, 128)) if k == 0: if im == 0: imgg = PILImage.new('RGB', (128, 30)) d = ImageDraw.Draw(imgg) d.text((stext, 0), str(np.round(out_gonet[k + 1][im], 2)), fill=(int(255 * (1.0 - out_gonet[k + 1][im])), int(255 * out_gonet[k + 1][im]), 0), font=font) imgtext = decode(imgg) imgtextcv = bridge.imgmsg_to_cv2(imgtext, 'bgr8') imgtextcvx = imgtextcv.transpose(2, 0, 1) imgc = np.concatenate((imgc, imgtextcvx), axis=1) # imgcc1 = imgc elif k == 1: if im == 0: imgg = PILImage.new('RGB', (128, 30)) d = ImageDraw.Draw(imgg) d.text((stext, 0), str(np.round(out_gonet[k + 1][im], 2)), fill=(int(255 * (1.0 - out_gonet[k + 1][im])), int(255 * out_gonet[k + 1][im]), 0), font=font) imgtext = decode(imgg) imgtextcv = bridge.imgmsg_to_cv2(imgtext, 'bgr8') imgtextcvx = imgtextcv.transpose(2, 0, 1) imgc = np.concatenate((imgc, imgtextcvx), axis=1) # imgcc2 = imgc elif k == 2: if im == 0: imgg = PILImage.new('RGB', (128, 30)) d = ImageDraw.Draw(imgg) d.text((stext, 0), str(np.round(out_gonet[k + 1][im], 2)), fill=(int(255 * (1.0 - out_gonet[k + 1][im])), int(255 * out_gonet[k + 1][im]), 0), font=font) imgtext = decode(imgg) imgtextcv = bridge.imgmsg_to_cv2(imgtext, 'bgr8') imgtextcvx = imgtextcv.transpose(2, 0, 1) imgc = np.concatenate((imgc, imgtextcvx), axis=1) # imgcc3 = imgc elif k == 3: if im == 0: imgg = PILImage.new('RGB', (128, 30)) d = ImageDraw.Draw(imgg) d.text((stext, 0), str(np.round(out_gonet[k + 1][im], 2)), fill=(int(255 * (1.0 - out_gonet[k + 1][im])), int(255 * out_gonet[k + 1][im]), 0), font=font) imgtext = decode(imgg) imgtextcv = bridge.imgmsg_to_cv2(imgtext, 'bgr8') imgtextcvx = imgtextcv.transpose(2, 0, 1) imgc = np.concatenate((imgc, imgtextcvx), axis=1) # imgcc4 = imgc imgcc = np.concatenate((imgcc0, imgcc1, imgcc2, imgcc3, imgcc4), axis=2) imgdd = imgcc.transpose(1, 2, 0) imgee = imgdd.astype(np.uint8) imgmm = bridge.cv2_to_imgmsg(imgee) image_all.publish(imgmm) j = 0
def view_2dmol(option, maps=None, out_put=None, target_id=None, legends=None, extra=None): """Function to render a mol image from a smiles. The input (option) could be 1) a list of smiles 2) a smiles 3) pdb_code Returns a molecule image as data""" option = str(option) print option try: option = ast.literal_eval(option) except: pass if type(option) is list: mols = [Chem.MolFromSmiles(str(x)) for x in option] p = Chem.MolFromSmarts(MCS.FindMCS(mols).smarts) AllChem.Compute2DCoords(p) [AllChem.GenerateDepictionMatching2DStructure(x, p) for x in mols] image = Draw.MolsToGridImage(mols, 2, legends=legends) # If it's a PDB code elif Chem.MolFromSmiles(str(option)) is None and type(option) is str: mol = Chem.MolFromSmiles( str( Molecule.objects.filter( prot_id__code=option)[0].cmpd_id.smiles)) AllChem.GenerateDepictionMatching3DStructure( mol, Chem.MolFromMolBlock( str(Molecule.objects.filter( prot_id__code=option)[0].sdf_info))) image = Draw.MolToImage(mol) # If it's a elif type(option) is str: mol = Chem.MolFromSmiles(str(option)) if extra == "SIMPLE": image = Draw.MolToImage(mol) elif extra is None: h_map = None image = Draw.MolToImage(mol, size=(100, 100), fitImage=True, highlightMap=h_map) else: sub = Chem.MolFromSmiles(str(extra)) h_map = get_h_map(mol, sub) image = Draw.MolToImage(mol, highlightMap=h_map) if maps is None: pass else: maps = float(maps) draw = ImageDraw.Draw(image) dim = (20, 0) + (20, image.size[1]) draw.line(dim, fill=(255 - int(255 * maps), int(255 * maps), 0), width=10) else: print "NOT VALID TYPE" return "NOT VALID TYPE" output = StringIO.StringIO() image.save(output, format="PNG") contents = output.getvalue() return contents
import Image import ImageDraw import ImagePalette spritesheet = Image.open('test_input.png') block_size = 30 palette_key = Image.new('P', (16 * block_size, 16 * block_size)) draw = ImageDraw.Draw(palette_key) print spritesheet.mode palette_key.putpalette(spritesheet.palette) x = 0 y = 0 for i in range(256): draw.rectangle([(x, y), (x + block_size, y + block_size)], fill=i) bg_size = draw.textsize(str(i)) text_pos = (x + (block_size / 4), y + (block_size / 3)) draw.rectangle([(text_pos[0] - 1, text_pos[1] + 1), (text_pos[0] + bg_size[0], text_pos[1] + bg_size[1] - 2)], fill=255) draw.text((x + (block_size / 4), y + (block_size / 3)), str(i), fill=1) x = x + block_size if x == 16 * block_size: x = 0 y = y + block_size palette_key.save('palette_key.png')
def create_legend(self, **kwargs): """self.legend is replaced from None to PIL image PIL image includes colorbar, caption, and titleString. **Modifies:** self.legend (PIL image) Parameters ----------- **kwargs : dict Any of Figure parameters """ # modify default parameters self._set_defaults(kwargs) # set fonts size for colorbar font = ImageFont.truetype(self.fontFileName, self.fontSize) # create a pilImage for the legend self.pilImgLegend = Image.new( 'P', (self.width, int(self.height * self.LEGEND_HEIGHT)), 255) draw = ImageDraw.Draw(self.pilImgLegend) # set black color if self.array.shape[0] == 1: black = 254 else: black = (0, 0, 0) # if 1 band, draw the color bar if self.array.shape[0] == 1: # make an array for color bar bar = np.outer( np.ones( max(int(self.pilImgLegend.size[1] * self.CBAR_HEIGHT), self.CBAR_HEIGHTMIN)), np.linspace(0, self.numOfColor, int(self.pilImgLegend.size[0] * self.CBAR_WIDTH))) # create a colorbar pil Image pilImgCbar = Image.fromarray(np.uint8(bar)) # paste the colorbar pilImage on Legend pilImage self.pilImgLegend.paste( pilImgCbar, (int(self.pilImgLegend.size[0] * self.CBAR_LOCATION_X), int(self.pilImgLegend.size[1] * self.CBAR_LOCATION_Y))) # create a scale for the colorbar scaleLocation = np.linspace(0, 1, self.numOfTicks) scaleArray = scaleLocation if self.logarithm: scaleArray = (np.power(scaleArray, (1.0 / self.gamma))) scaleArray = (scaleArray * (self.cmax[0] - self.cmin[0]) + self.cmin[0]) scaleArray = list(map(self._round_number, scaleArray)) # draw scales and lines on the legend pilImage for iTick in range(self.numOfTicks): coordX = int(scaleLocation[iTick] * self.pilImgLegend.size[0] * self.CBAR_WIDTH + int(self.pilImgLegend.size[0] * self.CBAR_LOCATION_X)) box = (coordX, int(self.pilImgLegend.size[1] * self.CBAR_LOCATION_Y), coordX, int(self.pilImgLegend.size[1] * (self.CBAR_LOCATION_Y + self.CBAR_HEIGHT)) - 1) draw.line(box, fill=black) box = (coordX + self.CBTICK_LOC_ADJUST_X, int(self.pilImgLegend.size[1] * (self.CBAR_LOCATION_Y + self.CBAR_HEIGHT)) + self.CBTICK_LOC_ADJUST_Y) draw.text(box, scaleArray[iTick], fill=black, font=font) # draw longname and units box = (int(self.pilImgLegend.size[0] * self.CAPTION_LOCATION_X), int(self.pilImgLegend.size[1] * self.CAPTION_LOCATION_Y)) draw.text(box, str(self.caption), fill=black, font=font) # if titleString is given, draw it if self.titleString != '': # write text each line onto pilImgCanvas textHeight = int(self.pilImgLegend.size[1] * self.TITLE_LOCATION_Y) for line in self.titleString.splitlines(): draw.text( (int(self.pilImgLegend.size[0] * self.TITLE_LOCATION_X), textHeight), line, fill=black, font=font) text = draw.textsize(line, font=font) textHeight += text[1]
import Image import ImageDraw import ImageFont width = 1280 height = 1280 if __name__ == "__main__": background = (255, 255, 255) rect = (40, 40, 40) im = Image.new("RGB", (width, height), background) d = ImageDraw.Draw(im) #f = ImageFont.truetype('/System/Library/Fonts/Keyboard.ttf', 80) #d.text([80, 80], 'Comparison of rectangles to one of a million pixels', font = f, fill = (230, 230, 230)) d.rectangle([80, 1183, 97, 1200], fill = rect) d.rectangle([80, 980, 100, 1000], fill = rect) d.rectangle([80, 776, 104, 800], fill = rect) d.rectangle([80, 570, 110, 600], fill = rect) d.rectangle([200, 200, 1200, 1200], fill = rect) im.save("image.png", "PNG")
def hasStdDrawObject(self, xSize, ySize): self.img = Image.new(modeRGB, (xSize, ySize), self.colors.background) self.hasDrawObject(ImageDraw.Draw(self.img)) return self
def plot_ld_heatmap(mat_file, bin_file, outfile, window_size=500000, summary_stat="unlinked_pct", cmap=DEFAULT_CMAP, missing_color=(255, 255, 255), bg_color=(255, 255, 255), chrm_color=(0, 0, 0), tics=False, font_file="/Library/Fonts/Microsoft/Arial.ttf", font_size=80): """ Create a triangle heatmap plot from a numpy matrix of pairwise-bin values. Each cel of the matrix is a summary statistic (e.g. mean or 95th percentile) of the LD between the two bins. The matrix can either be square or upper-right-hand. bins is a three-column matrix: chrmosome, start position, summary value. TODO: support creating diamond heatmaps from a square matrix. """ import csv def load_matrix(x, first): with open(abspath(x), "rU") as i: r = csv.reader(i, delimiter=",") h = r.next()[first:] m = np.array(list( map(lambda x: float("nan" if x == "NA" else x), row[first:]) for row in r), dtype=np.float64) return (h, m) mat = load_matrix(mat_file, 1)[1] #mat = mat[0:5063,0:5063] bin_cols, bins = load_matrix(bin_file, 0) #bins = bins[0:5063,] chrm_col = which("chrm", bin_cols) stat_col = which(summary_stat, bin_cols) chrms = bins[:, chrm_col] chrm_idxs = np.unique(chrms, return_index=True)[1] chrms = [int(chrms[index]) for index in sorted(chrm_idxs)] # TODO: this is a hack. Fix the process_ld_file function to write blank lines for missing windows row = 0 nan = float("nan") blank = [nan] * (bins.shape[1] - 3) for chrm in chrms: pos = 0 while row < bins.shape[0] and int(bins[row, chrm_col]) == chrm: if int(bins[row, 1]) != pos: bins = np.insert(bins, row, [chrm, pos, 0] + blank, axis=0) mat = np.insert(mat, row, nan, axis=0) mat = np.insert(mat, row, nan, axis=1) row += 1 pos += window_size mat_size = mat.shape[0] assert mat_size == mat.shape[1], "Matrix is not square" assert mat_size == len(bins), "Matrix and bins are of different size" def convert_chrm(c): c = int(c) return "X" if c == 23 else str(c) chrms = map(convert_chrm, bins[..., chrm_col]) im = Image.new("RGB", (mat_size + X_OFFSETS[4], mat_size + Y_OFFSETS[0]), bg_color) pixels = im.load() draw = ImageDraw.Draw(im) font = ImageFont.truetype(font_file, font_size) chrm_id = None chrm_end = 0 tic_interval = 10000000 / window_size for row, summary in enumerate(bins[..., stat_col]): chrm = chrms[row] def get_line_coords(start, end): x1 = row + X_OFFSETS[start] y1 = row + Y_OFFSETS[start] x2 = row + X_OFFSETS[end] y2 = row + Y_OFFSETS[end] return ((x1, y1), (x2, y2)) # draw summary line color = heatmap(summary, cmap) if not np.isnan(summary) and summary > 0 else 0 draw.line(get_line_coords(2, 3), fill=color) for col in xrange(row, mat_size): x = col + X_OFFSETS[4] val = mat[row, col] if np.isnan(val) or val < 0: pixels[x, row] = missing_color else: pixels[x, row] = heatmap(val, cmap) # Label chromosome boundaries if chrm != chrm_id or row == (mat_size - 1): draw.line(get_line_coords(0, 2), fill=chrm_color, width=5) if chrm_id is not None: # first draw text in a blank image, then rotate and paste into the main image txt = str(chrm_id) txt_size = draw.textsize(txt, font=font) txt_img = Image.new("L", txt_size) txt_draw = ImageDraw.Draw(txt_img) txt_draw.text((0, 0), txt, font=font, fill=255) txt_img = txt_img.rotate(-45, expand=1) offset = max(txt_size[0], txt_size[1]) lft_indent = int(math.floor((txt_img.size[0] - offset) / 2)) top_indent = int(math.floor((txt_img.size[1] - offset) / 2)) txt_img = txt_img.crop( (lft_indent, top_indent, txt_img.size[0] - lft_indent, txt_img.size[1] - top_indent)) text_row = int(chrm_end + ((row - chrm_end) / 2)) text_x = int(text_row + X_OFFSETS[0] + ((X_OFFSETS[2] - X_OFFSETS[0]) / 2) - (txt_img.size[0] / 2)) text_y = int(text_row + Y_OFFSETS[0] + ((Y_OFFSETS[2] - Y_OFFSETS[0]) / 2) - (txt_img.size[1] / 2)) im.paste(ImageOps.colorize(txt_img, bg_color, chrm_color), (text_x, text_y)) chrm_id = chrm chrm_end = row # add tics if tics and ((row - chrm_end) % tic_interval) == 0: draw.line(get_line_coords(1, 2), fill=chrm_color, width=3) # convert to RGBA (required for background recoloring) im2 = im.convert("RGBA") # rotate im2 = im2.rotate(45, expand=True) # recolor background bg = Image.new("RGBA", im2.size, (255, ) * 4) im2 = Image.composite(im2, bg, im2) # convert back to RGB im = im2.convert(im.mode) # crop final_height = int(math.ceil( math.sqrt(2 * math.pow(mat_size, 2)) / 2)) + OFFSETS[-1] im = im.crop((0, 0, im.size[0], final_height)) # save im.save(outfile)
def frame(self, imarray): # No calibration params yet. if not self.vo: return if self.seq > 10000: sys.exit() if DEBUG: print "" print "" print "Frame ", self.seq print "" print "" im = imarray.images[1] im_r = imarray.images[0] if im.colorspace == "mono8": im_py = Image.fromstring("L", (im.width, im.height), im.data) im_r_py = Image.fromstring("L", (im_r.width, im_r.height), im_r.data) elif im.colorspace == "rgb24": use_color = True im_col_py = Image.fromstring("RGB", (im.width, im.height), im.data) im_py = im_col_py.convert("L") im_r_py = Image.fromstring("RGB", (im_r.width, im_r.height), im_r.data) im_r_py = im_r_py.convert("L") else: print "Unknown colorspace" return # Detect faces on the first frame if not self.current_keyframes: self.faces = self.p.detectAllFaces(im_py.tostring(), im.width, im.height, self.cascade_file, 1.0, None, None, True) if DEBUG: print "Faces ", self.faces sparse_pred_list = [] sparse_pred_list_2d = [] old_rect = [0, 0, 0, 0] ia = SparseStereoFrame(im_py, im_r_py) ia.matches = [] ia.desc_diffs = [] ia.good_matches = [] # Track each face iface = -1 for face in self.faces: iface += 1 (x, y, w, h) = copy.copy(self.faces[iface]) if DEBUG: print "A face ", (x, y, w, h) (old_center, old_diff) = self.rect_to_center_diff((x, y, w, h)) if self.face_centers_3d and iface < len(self.face_centers_3d): censize3d = list(copy.copy(self.face_centers_3d[iface])) censize3d.append(2.0 * self.real_face_sizes_3d[iface]) ###ZMULT self.get_features(ia, self.num_feats, (x, y, w, h), censize3d) else: self.get_features(ia, self.num_feats, (x, y, w, h), (0.0, 0.0, 0.0, 1000000.0)) if not ia.kp2d: continue # First frame: if len(self.current_keyframes) < iface + 1: (cen, diff) = self.rect_to_center_diff((x, y, w, h)) cen3d = self.cam.pix2cam(cen[0], cen[1], ia.avgd) cen3d = list(cen3d) ltf = self.cam.pix2cam(x, y, ia.avgd) rbf = self.cam.pix2cam(x + w, y + h, ia.avgd) fs3d = ((rbf[0] - ltf[0]) + (rbf[1] - ltf[1])) / 4.0 # This assumes that we're tracking the face plane center, not the center of the head sphere. # If you want to track the center of the sphere instead, do: cen3d[2] += fs3d # Check that the face is a reasonable size. If not, skip this face. if 2 * fs3d < self.min_real_face_size or 2 * fs3d > self.max_real_face_size or iface > 1: #HACK: ONLY ALLOW ONE FACE self.faces.pop(iface) iface -= 1 continue if DESCRIPTOR == 'CALONDER': self.vo.collect_descriptors(ia) elif DESCRIPTOR == 'SAD': self.vo.collect_descriptors_sad(ia) else: pass self.current_keyframes.append(0) self.keyframes.append(copy.copy(ia)) self.feats_to_centers.append( self.make_face_model(cen, diff, ia.kp2d)) self.real_face_sizes_3d.append(copy.deepcopy(fs3d)) self.feats_to_centers_3d.append( self.make_face_model(cen3d, (fs3d, fs3d, fs3d), ia.kp3d)) self.face_centers_3d.append(copy.deepcopy(cen3d)) self.recent_good_frames.append(copy.copy(ia)) self.recent_good_rects.append(copy.deepcopy([x, y, w, h])) self.recent_good_centers_3d.append(copy.deepcopy(cen3d)) self.recent_good_motion.append([0.0] * 3) #dx,dy,dimfacesize self.recent_good_motion_3d.append([0.0] * 3) self.same_key_rgfs.append(True) if DEBUG: print "cen2d", cen print "cen3d", self.face_centers_3d[iface] # End first frame # Later frames else: if DESCRIPTOR == 'CALONDER': self.vo.collect_descriptors(ia) elif DESCRIPTOR == 'SAD': self.vo.collect_descriptors_sad(ia) else: pass done_matching = False bad_frame = False while not done_matching: # Try matching to the keyframe keyframe = self.keyframes[self.current_keyframes[iface]] temp_match = self.vo.temporal_match(ia, keyframe, want_distances=True) ia.matches = [(m2, m1) for (m1, m2, m3) in temp_match] ia.desc_diffs = [m3 for (m1, m2, m3) in temp_match] print "temp matches", temp_match ia.good_matches = [ s < self.desc_diff_thresh for s in ia.desc_diffs ] n_good_matches = len([ m for m in ia.desc_diffs if m < self.desc_diff_thresh ]) if DEBUG: if len(keyframe.kp) < 2: print "Keyframe has less than 2 kps" if n_good_matches < len(keyframe.kp) / 2.0: print "ngoodmatches, len key.kp, len key.kp/2", n_good_matches, len( keyframe.kp), len(keyframe.kp) / 2.0 # Not enough matches, get a new keyframe if len(keyframe.kp) < 2 or n_good_matches < len( keyframe.kp) / 2.0: if DEBUG: print "New keyframe" # Make a new face model, either from a recent good frame, or from the current image if not self.same_key_rgfs[iface]: if DEBUG: print "centers at beginning of new keyframe" print "cen2d", [ self.faces[iface][0] + self.faces[iface][2] / 2.0, self.faces[iface][1] + self.faces[iface][3] / 2.0 ] print "cen3d", self.face_centers_3d[iface] matched_z_list = [ kp3d[2] for (kp3d, is_good) in zip( self.recent_good_frames[iface].kp3d, self. recent_good_frames[iface].good_matches) if is_good ] if len(matched_z_list) == 0: matched_z_list = [ kp3d[2] for kp3d in self.recent_good_frames[iface].kp3d ] avgz_goodmatches = sum(matched_z_list) / len( matched_z_list) tokeep = [ math.fabs( self.recent_good_frames[iface].kp3d[i][2] - avgz_goodmatches) < 2.0 * self.real_face_sizes_3d[iface] for i in range( len(self.recent_good_frames[iface].kp3d)) ] kp3d_for_model = [ kp3d for (kp3d, tk) in zip( self.recent_good_frames[iface].kp3d, tokeep) if tk ] kp_for_model = [ kp for (kp, tk) in zip( self.recent_good_frames[iface].kp, tokeep) if tk ] # If you're not left with enough points, just take all of them and don't worry about the depth constraints. if len(kp3d_for_model) < 2: kp3d_for_model = copy.deepcopy( self.recent_good_frames[iface].kp3d) kp_for_model = copy.deepcopy( self.recent_good_frames[iface].kp) (cen, diff) = self.rect_to_center_diff( self.recent_good_rects[iface]) self.feats_to_centers[ iface] = self.make_face_model( cen, diff, [(kp0, kp1) for (kp0, kp1, kp2) in kp_for_model]) cen3d = self.recent_good_centers_3d[iface] self.feats_to_centers_3d[ iface] = self.make_face_model( cen3d, [self.real_face_sizes_3d[iface]] * 3, kp3d_for_model) self.keyframes[ self.current_keyframes[iface]] = copy.copy( self.recent_good_frames[iface]) self.keyframes[self.current_keyframes[ iface]].kp = kp_for_model self.keyframes[ self.current_keyframes[iface]].kp2d = [ (k0, k1) for (k0, k1, k2) in kp_for_model ] self.keyframes[self.current_keyframes[ iface]].kp3d = kp3d_for_model self.keyframes[ self.current_keyframes[iface]].matches = [ (i, i) for i in range(len(kp_for_model)) ] self.keyframes[ self.current_keyframes[iface]].good_matches = [ True ] * len(kp_for_model) self.keyframes[self.current_keyframes[ iface]].desc_diffs = [0] * len(kp_for_model) if DESCRIPTOR == 'CALONDER': self.vo.collect_descriptors(self.keyframes[ self.current_keyframes[iface]]) elif DESCRIPTOR == 'SAD': self.vo.collect_descriptors_sad(self.keyframes[ self.current_keyframes[iface]]) else: pass self.face_centers_3d[iface] = copy.deepcopy(cen3d) # Not changing the face size self.current_keyframes[ iface] = 0 #### HACK: ONLY ONE KEYFRAME!!! self.same_key_rgfs[iface] = True # Don't need to change the recent good frame yet. if DEBUG: print "centers at end of new keyframe" print "cen2d", [ self.faces[iface][0] + self.faces[iface][2] / 2.0, self.faces[iface][1] + self.faces[iface][3] / 2.0 ] print "cen3d", self.face_centers_3d[iface] else: # Making a new model off of the current frame but with the predicted new position. # HACK: The displacement computation assumes that the robot/head is still, fix this. bad_frame = True #done_matching = True if DEBUG: print "Bad frame ", self.seq, " for face ", iface (cen, diff) = self.rect_to_center_diff( self.faces[iface]) if DEBUG: print "Motion for bad frame ", self.recent_good_motion[ iface], self.recent_good_motion_3d[iface] new_cen = [ cen[0] + self.recent_good_motion[iface][0], cen[1] + self.recent_good_motion[iface][1] ] diff = [ diff[0] + self.recent_good_motion[iface][2], diff[1] + self.recent_good_motion[iface][2] ] self.faces[iface] = (new_cen[0] - diff[0], new_cen[1] - diff[1], 2.0 * diff[0], 2.0 * diff[1]) (x, y, w, h) = copy.deepcopy(self.faces[iface]) pred_cen_3d = [ o + n for (o, n) in zip( self.face_centers_3d[iface], self.recent_good_motion_3d[iface]) ] pred_cen_3d.append( 2.0 * self.real_face_sizes_3d[iface]) #### ZMULT self.get_features(ia, self.num_feats, (x, y, w, h), pred_cen_3d) if not ia.kp2d: break if DESCRIPTOR == 'CALONDER': self.vo.collect_descriptors(ia) elif DESCRIPTOR == 'SAD': self.vo.collect_descriptors_sad(ia) else: pass self.keyframes[ self.current_keyframes[iface]] = copy.copy(ia) self.current_keyframes[iface] = 0 (cen, diff) = self.rect_to_center_diff( self.faces[iface]) self.feats_to_centers[ iface] = self.make_face_model( cen, diff, ia.kp2d) self.feats_to_centers_3d[ iface] = self.make_face_model([ pred_cen_3d[0], pred_cen_3d[1], pred_cen_3d[2] ], [self.real_face_sizes_3d[iface]] * 3, ia.kp3d) self.face_centers_3d[iface] = copy.deepcopy( pred_cen_3d) self.same_key_rgfs[iface] = True # Good matches, mark this frame as good else: done_matching = True # END MATCHING # If we got enough matches for this frame, track. if ia.kp and ia.kp2d: # Track sparse_pred_list = [] sparse_pred_list_2d = [] probs = [] bandwidths = [] size_mult = 0.05 #1.0 for ((match1, match2), score) in zip(ia.matches, ia.desc_diffs): if score < self.desc_diff_thresh: sparse_pred_list.append([ ia.kp3d[match2][i] + self.feats_to_centers_3d[iface][match1][i] for i in range(3) ]) sparse_pred_list_2d.append([ ia.kp2d[match2][i] + self.feats_to_centers[iface][match1][i] for i in range(2) ]) #probs.append(score) probs = [1.0] * len( sparse_pred_list_2d ) # Ignore actual match scores. Uncomment line above to use the match scores. bandwidths = [size_mult * self.real_face_sizes_3d[iface] ] * len(sparse_pred_list_2d) (old_center, old_diff) = self.rect_to_center_diff(self.faces[iface]) if DEBUG: print "Old center 3d ", self.face_centers_3d[iface] print "Old center 2d ", old_center old_rect = self.faces[iface] # For display only new_center = self.mean_shift_sparse( self.face_centers_3d[iface][0:3], sparse_pred_list, probs, bandwidths, 10, 1.0) new_center_2d = self.cam.cam2pix(new_center[0], new_center[1], new_center[2]) # The above line assumes that we're tracking the face plane center, not the center of the head sphere. # If you want to track the center of the sphere instead, subtract self.real_face_sizes[iface] from the z-coord. ltf = self.cam.cam2pix( new_center[0] - self.real_face_sizes_3d[iface], new_center[1] - self.real_face_sizes_3d[iface], new_center[2]) rbf = self.cam.cam2pix( new_center[0] + self.real_face_sizes_3d[iface], new_center[1] + self.real_face_sizes_3d[iface], new_center[2]) w = rbf[0] - ltf[0] h = rbf[1] - ltf[1] if DEBUG: print "new center 3d ", new_center print "new_center 2d ", new_center_2d (nx, ny, nw, nh) = (new_center_2d[0] - (w - 1) / 2.0, new_center_2d[1] - (h - 1) / 2.0, w, h) # Force the window back into the image. nx += max(0, 0 - nx) + min(0, im.width - nx + nw) ny += max(0, 0 - ny) + min(0, im.height - ny + nh) self.faces[iface] = [nx, ny, nw, nh] self.recent_good_rects[iface] = [nx, ny, nw, nh] self.recent_good_centers_3d[iface] = copy.deepcopy( new_center) if bad_frame: self.recent_good_motion[ iface] = self.recent_good_motion[iface] self.recent_good_motion_3d[ iface] = self.recent_good_motion_3d[iface] else: self.recent_good_motion[iface] = [ new_center_2d[0] - old_center[0], new_center_2d[1] - old_center[1], ((nw - 1.0) / 2.0) - old_diff[0] ] self.recent_good_motion_3d[iface] = [ new_center[i] - self.face_centers_3d[iface][i] for i in range(len(new_center)) ] self.face_centers_3d[iface] = copy.deepcopy(new_center) self.recent_good_frames[iface] = copy.copy(ia) self.same_key_rgfs[iface] = False if DEBUG: print "motion ", self.recent_good_motion[ iface], self.recent_good_motion_3d[iface] print "face 2d ", self.faces[iface] print "face center 3d ", self.face_centers_3d[iface] # Output the location of this face center in the 3D camera frame (of the left camera), and rotate # the coordinates to match the robot's idea of the 3D camera frame. center_uvd = (nx + (nw - 1) / 2.0, ny + (nh - 1) / 2.0, (numpy.average(ia.kp, 0))[2]) center_camXYZ = self.cam.pix2cam(center_uvd[0], center_uvd[1], center_uvd[2]) center_robXYZ = (center_camXYZ[2], -center_camXYZ[0], -center_camXYZ[1]) ########### PUBLISH the face center for the head controller to track. ######## if not self.usebag: #stamped_point = PointStamped() #(stamped_point.point.x, stamped_point.point.y, stamped_point.point.z) = center_robXYZ #stamped_point.header.frame_id = "stereo" #stamped_point.header.stamp = imarray.header.stamp #self.pub.publish(stamped_point) pm = PositionMeasurement() pm.header.stamp = imarray.header.stamp pm.name = "stereo_face_feature_tracker" pm.object_id = -1 (pm.pos.x, pm.pos.y, pm.pos.z) = center_robXYZ pm.header.frame_id = "stereo_link" pm.reliability = 0.5 pm.initialization = 0 #pm.covariance self.pub.publish(pm) # End later frames ############ DRAWING ################ if SAVE_PICS: if not self.keyframes or len(self.keyframes) <= iface: bigim_py = im_py draw = ImageDraw.Draw(bigim_py) else: key_im = self.keyframes[self.current_keyframes[iface]] keyim_py = Image.fromstring("L", key_im.size, key_im.rawdata) bigim_py = Image.new( "RGB", (im_py.size[0] + key_im.size[0], im_py.size[1])) bigim_py.paste(keyim_py.convert("RGB"), (0, 0)) bigim_py.paste(im_py, (key_im.size[0] + 1, 0)) draw = ImageDraw.Draw(bigim_py) (x, y, w, h) = self.faces[iface] draw.rectangle((x, y, x + w, y + h), outline=(0, 255, 0)) draw.rectangle( (x + key_im.size[0], y, x + w + key_im.size[0], y + h), outline=(0, 255, 0)) (x, y, w, h) = old_rect draw.rectangle((x, y, x + w, y + h), outline=(255, 255, 255)) draw.rectangle( (x + key_im.size[0], y, x + w + key_im.size[0], y + h), outline=(255, 255, 255)) mstart = old_center mend = (old_center[0] + self.recent_good_motion[iface][0], old_center[1] + self.recent_good_motion[iface][1]) draw.rectangle((mstart[0] - 1, mstart[1] - 1, mstart[0] + 1, mstart[1] + 1), outline=(255, 255, 255)) draw.rectangle( (mend[0] - 1, mend[1] - 1, mend[0] + 1, mend[1] + 1), outline=(0, 255, 0)) draw.line(mstart + mend, fill=(255, 255, 255)) for (x, y) in key_im.kp2d: draw_x(draw, (x, y), (1, 1), (255, 0, 0)) for (x, y) in ia.kp2d: draw_x(draw, (x + key_im.size[0], y), (1, 1), (255, 0, 0)) if self.seq > 0: if ia.matches: for ((m1, m2), score) in zip(ia.matches, ia.desc_diffs): if score > self.desc_diff_thresh: color = (255, 0, 0) else: color = (0, 255, 0) draw.line( (key_im.kp2d[m1][0], key_im.kp2d[m1][1], ia.kp2d[m2][0] + key_im.size[0], ia.kp2d[m2][1]), fill=color) for (i, (u, v)) in enumerate(sparse_pred_list_2d): bscale = min(1, probs[i] / 0.01) draw_x(draw, (u, v), (1, 1), (128.0 + 128.0 * bscale, 128.0 + 128.0 * bscale, (1.0 - bscale) * 255.0)) draw_x(draw, (u + key_im.size[0], v), (1, 1), (128.0 + 128.0 * bscale, 128.0 + 128.0 * bscale, (1.0 - bscale) * 255.0)) ####### PUBLISH 3d visualization point cloud ################### if self.usebag and self.visualize: cloud = PointCloud() cloud.header.frame_id = "stereo" cloud.header.stamp = imarray.header.stamp cloud.pts = [] cloud.pts.append(Point()) (cloud.pts[0].x, cloud.pts[0].y, cloud.pts[0].z) = self.face_centers_3d[iface][:3] for (i, kp3d) in enumerate(ia.kp3d): cloud.pts.append(Point()) (cloud.pts[i].x, cloud.pts[i].y, cloud.pts[i].z) = kp3d lp = len(cloud.pts) if self.seq > 0: for (i, (u, v)) in enumerate(sparse_pred_list): cloud.pts[lp + i].append(Point()) (cloud.pts[lp + i].x, cloud.pts[lp + i].y, cloud.pts[lp + i].z) = sparse_pred_list[i][:3] self.pub.publish(cloud) bigim_py.save("/tmp/tiff/feats%06d_%03d.tiff" % (self.seq, iface)) #END DRAWING # END FACE LOOP self.seq += 1
def assembleBanner(self, name, medals, insignia): width, height = self.sizeBanner(name, medals, insignia) oheight = height bwidth = 4 height = max(insignia.size[1] + 2 * bwidth, height) xpos = 2 * bwidth ypos = 2 * bwidth linesize = 16 image = Image.new("RGBA", (width, height), (0, 0, 0, 0)) draw = ImageDraw.Draw(image) # Draw Border draw.rectangle([(0, bwidth), (width, height - (bwidth + 1))], fill=ImageColor.getrgb(TRIM_COLOR)) draw.rectangle([(bwidth, 0), (width - (bwidth + 1), height)], fill=ImageColor.getrgb(TRIM_COLOR)) draw.rectangle([(bwidth, 2 * bwidth), (width - (bwidth + 1), height - 2 * (bwidth + 1))], fill=ImageColor.getrgb(BG_COLOR)) draw.rectangle([(2 * bwidth, bwidth), (width - 2 * (bwidth + 1), height - (bwidth + 1))], fill=ImageColor.getrgb(BG_COLOR)) # Draw Name, Rank, Kills, Deaths, KD, Favorite Weapon, Rank image.paste(insignia, (width - (insignia.size[0] + 2 * bwidth), height / 2 - insignia.size[1] / 2), insignia) namewidth, nameheight = self.yoster24.getsize(name) maxwidth = 525 - (2 * bwidth + insignia.size[0]) fw, fh = self.yoster12.getsize(WATERMARK) if oheight == 50: #if it's just one line for medalset in medals: image.paste(medalset, (xpos, ypos), medalset) xpos += medalset.size[0] + 4 if self.gold: draw.text((xpos, ypos), name, font=self.yoster24, fill=GOLD_SHADOW) draw.text((xpos - 1, ypos - 1), name, font=self.yoster24, fill=GOLD_COLOR) else: draw.text((xpos, ypos), name, font=self.yoster24, fill=(155, 155, 155)) draw.text((xpos - 1, ypos - 1), name, font=self.yoster24, fill=(0xFF, 0xFF, 0xFF)) draw.text((xpos + 2, height - 16), WATERMARK, font=self.yoster12, fill=WATERMARK_COLOR) else: #if it's multiline ypos += linesize medalwidth = reduce(lambda x, y: x + y.size[0], medals, 0) if self.gold: draw.text((((width / 2) - (namewidth / 2)) + 1, 4 + 1), name, font=self.yoster24, fill=GOLD_SHADOW) draw.text(((width / 2) - (namewidth / 2), 4), name, font=self.yoster24, fill=GOLD_COLOR) else: draw.text((((width / 2) - (namewidth / 2)) + 1, 4 + 1), name, font=self.yoster24, fill=(155, 155, 155)) draw.text(((width / 2) - (namewidth / 2), 4), name, font=self.yoster24, fill=(0xFF, 0xFF, 0xFF)) #draw.text(,name,font=self.yoster24,fill=(155,155,155)) # text shadow #draw.text(,4),name,font=self.yoster24) ypos += 4 spacing = 8 xpos = bwidth + spacing for medalset in medals: if xpos + medalset.size[0] > maxwidth: ypos += linesize + 2 xpos = bwidth image.paste(medalset, (xpos, ypos), medalset) xpos += medalset.size[0] + spacing draw.text(((width / 2) - (fw / 2), height - 16), WATERMARK, font=self.yoster12, fill=WATERMARK_COLOR) #draw.text((14,height-16),"Dr. Frink's FUNHOUSE",font=yoster12,fill=(136,0,0)) #draw.text((width-(fw+14),height-16),WATERMARK,font=yoster12,fill=(136,0,0)) return image
import ariturtle import math import copy import Image, ImageDraw import sys usrS = int(raw_input('Enter Image Size: ')) depth = int(raw_input('Enter Recursion Depth: ')) img = Image.new('RGB', (usrS, usrS)) imageSize = img.size draw = ImageDraw.Draw(img) sys.setrecursionlimit(1000) global size def drawBasic(turtle, level, angle=90): global size if level == 0: return ariturtle.turn(turtle, angle) drawBasic(turtle, level - 1, -angle) ariturtle.move(turtle, size) ariturtle.turn(turtle, -angle) drawBasic(turtle, level - 1, angle)
def coordToMask(polygon, dims): img = Image.new('L', (dims[0], dims[1]), 0) ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1) return img
def run_calibration(self, calibration_points, move_duration=1.5, shuffle=True, start_key='space', decision_key='space', text_color='white', enable_mouse=False): """ Run calibration. :param calibration_points: List of position of calibration points. :param float move_duration: Duration of animation of calibration target. Unit is second. Default value is 1.5. :param bool shuffle: If True, order of calibration points is shuffled. Otherwise, calibration target moves in the order of calibration_points. Default value is True. :param str start_key: Name of key to start calibration procedure. If None, calibration starts immediately afte this method is called. Default value is 'space'. :param str decision_key: Name of key to accept/retry calibration. Default value is 'space'. :param text_color: Color of message text. Default value is 'white' :param bool enable_mouse: If True, mouse operation is enabled. Default value is False. """ if self.eyetracker is None: raise RuntimeError('Eyetracker is not found.') if not (2 <= len(calibration_points) <= 9): raise ValueError('Calibration points must be 2~9') if enable_mouse: mouse = psychopy.event.Mouse(visible=False, win=self.win) img = Image.new('RGBA', tuple(self.win.size)) img_draw = ImageDraw.Draw(img) result_img = psychopy.visual.SimpleImageStim(self.win, img, autoLog=False) result_msg = psychopy.visual.TextStim(self.win, pos=(0, -self.win.size[1] / 4), color=text_color, units='pix', autoLog=False) remove_marker = psychopy.visual.Circle( self.win, radius=self.calibration_target_dot.radius * 5, fillColor='black', lineColor='white', lineWidth=1, autoLog=False) if self.win.units == 'norm': # fix oval remove_marker.setSize( [float(self.win.size[1]) / self.win.size[0], 1.0]) remove_marker.setSize( [float(self.win.size[1]) / self.win.size[0], 1.0]) self.calibration.enter_calibration_mode() self.move_duration = move_duration self.original_calibration_points = calibration_points[:] self.retry_points = list(range(len( self.original_calibration_points))) # set all points in_calibration_loop = True while in_calibration_loop: self.calibration_points = [] for i in range(len(self.original_calibration_points)): if i in self.retry_points: self.calibration_points.append( self.original_calibration_points[i]) if shuffle: np.random.shuffle(self.calibration_points) if start_key is not None or enable_mouse: waitkey = True if start_key is not None: if enable_mouse: result_msg.setText( 'Press {} or click left button to start calibration' .format(start_key)) else: result_msg.setText( 'Press {} to start calibration'.format(start_key)) else: # enable_mouse==True result_msg.setText( 'Click left button to start calibration') while waitkey: for key in psychopy.event.getKeys(): if key == start_key: waitkey = False if enable_mouse and mouse.getPressed()[0]: waitkey = False result_msg.draw() self.win.flip() else: self.win.flip() self.update_calibration() calibration_result = self.calibration.compute_and_apply() self.win.flip() img_draw.rectangle(((0, 0), tuple(self.win.size)), fill=(0, 0, 0, 0)) if calibration_result.status == tobii_research.CALIBRATION_STATUS_FAILURE: #computeCalibration failed. pass else: if len(calibration_result.calibration_points) == 0: pass else: for calibration_point in calibration_result.calibration_points: p = calibration_point.position_on_display_area for calibration_sample in calibration_point.calibration_samples: lp = calibration_sample.left_eye.position_on_display_area rp = calibration_sample.right_eye.position_on_display_area if calibration_sample.left_eye.validity == tobii_research.VALIDITY_VALID_AND_USED: img_draw.line(((p[0] * self.win.size[0], p[1] * self.win.size[1]), (lp[0] * self.win.size[0], lp[1] * self.win.size[1])), fill=(0, 255, 0, 255)) if calibration_sample.right_eye.validity == tobii_research.VALIDITY_VALID_AND_USED: img_draw.line(((p[0] * self.win.size[0], p[1] * self.win.size[1]), (rp[0] * self.win.size[0], rp[1] * self.win.size[1])), fill=(255, 0, 0, 255)) img_draw.ellipse(((p[0] * self.win.size[0] - 3, p[1] * self.win.size[1] - 3), (p[0] * self.win.size[0] + 3, p[1] * self.win.size[1] + 3)), outline=(0, 0, 0, 255)) if enable_mouse: result_msg.setText( 'Accept/Retry: {} or right-click\nSelect recalibration points: 0-9 key or left-click\nAbort: esc' .format(decision_key)) else: result_msg.setText( 'Accept/Retry: {}\nSelect recalibration points: 0-9 key\nAbort: esc' .format(decision_key)) result_img.setImage(img) waitkey = True self.retry_points = [] if enable_mouse: mouse.setVisible(True) while waitkey: for key in psychopy.event.getKeys(): if key in [decision_key, 'escape']: waitkey = False elif key in ['0', 'num_0']: if len(self.retry_points) == 0: self.retry_points = list( range(len(self.original_calibration_points))) else: self.retry_points = [] elif key in self.key_index_dict: key_index = self.key_index_dict[key] if key_index < len(self.original_calibration_points): if key_index in self.retry_points: self.retry_points.remove(key_index) else: self.retry_points.append(key_index) if enable_mouse: pressed = mouse.getPressed() if pressed[2]: # right click key = decision_key waitkey = False elif pressed[0]: # left click mouse_pos = mouse.getPos() for key_index in range( len(self.original_calibration_points)): p = self.original_calibration_points[key_index] if np.linalg.norm([ mouse_pos[0] - p[0], mouse_pos[1] - p[1] ]) < self.calibration_target_dot.radius * 5: if key_index in self.retry_points: self.retry_points.remove(key_index) else: self.retry_points.append(key_index) time.sleep(0.2) break result_img.draw() if len(self.retry_points) > 0: for index in self.retry_points: if index > len(self.original_calibration_points): self.retry_points.remove(index) remove_marker.setPos( self.original_calibration_points[index]) remove_marker.draw() result_msg.draw() self.win.flip() if key == decision_key: if len(self.retry_points) == 0: retval = 'accept' in_calibration_loop = False else: #retry for point_index in self.retry_points: x, y = self.get_tobii_pos( self.original_calibration_points[point_index]) self.calibration.discard_data(x, y) elif key == 'escape': retval = 'abort' in_calibration_loop = False else: raise RuntimeError('Calibration: Invalid key') if enable_mouse: mouse.setVisible(False) self.calibration.leave_calibration_mode() if enable_mouse: mouse.setVisible(False) return retval
def plot_rgb_histogram(img): # RGB Hitogram # This script will create a histogram image based on the RGB content of # an image. It uses PIL to do most of the donkey work but then we just # draw a pretty graph out of it. # # May 2009, Scott McDonough, www.scottmcdonough.co.uk # import Image, ImageDraw imagepath = "mZXN_1979" # The image to build the histogram of histHeight = 120 # Height of the histogram histWidth = 256 # Width of the histogram multiplerValue = 1 # The multiplier value basically increases # the histogram height so that love values # are easier to see, this in effect chops off # the top of the histogram. showFstopLines = True # True/False to hide outline fStopLines = 5 # Colours to be used backgroundColor = (51, 51, 51) # Background color lineColor = (102, 102, 102) # Line color of fStop Markers red = (255, 60, 60) # Color for the red lines green = (51, 204, 51) # Color for the green lines blue = (0, 102, 255) # Color for the blue lines ################################################################################## #img = Image.open(imagepath) hist = img.histogram() histMax = max(hist) # comon color xScale = float((histWidth)) / len(hist) # xScaling yScale = float((histHeight)) / histMax # yScaling im = Image.new("RGBA", ((histWidth * multiplerValue), (histHeight * multiplerValue)), backgroundColor) draw = ImageDraw.Draw(im) # Draw Outline is required if showFstopLines: xmarker = histWidth / fStopLines x = 0 for i in range(1, fStopLines + 1): draw.line((x, 0, x, histHeight), fill=lineColor) x += xmarker draw.line((histWidth - 1, 0, histWidth - 1, 200), fill=lineColor) draw.line((0, 0, 0, histHeight), fill=lineColor) # Draw the RGB histogram lines x = 0 c = 0 for i in hist: if int(i) == 0: pass else: color = red if c > 255: color = green if c > 511: color = blue draw.line((x, histHeight, x, histHeight - (i * yScale)), fill=color) if x > 255: x = 0 else: x += 1 c += 1 # Now save and show the histogram im.save('histogram.png', 'PNG') #im.show() return im
+ gif) #print gifDirectory gifSpeed = os.listdir( "/home/pi/Documents/LEDMatrix/rpi-rgb-led-matrix-master/gifSpeed" )[0] hexa = os.listdir( "/home/pi/Documents/LEDMatrix/rpi-rgb-led-matrix-master/Color")[0] curDate = datetime.datetime.now().strftime("%H:%M") image = Image.new("1", (30, 12)) # Can be larger than matrix if wanted!! image = image.convert("RGBA") draw = ImageDraw.Draw(image) # Declare Draw instance before prims draw.text((0, 0), curDate, fill=hex_to_rgb(hexa)) # draw.text((0, 0), curDate, fill=(int(float(r)), int(float(g)), int(float(b)))) # matrix.Clear() matrix.SetImage(image.im.id, 0, 0) for n in range(1, len(gifDirectory) + 1): pict = Image.open( "/home/pi/Documents/LEDMatrix/rpi-rgb-led-matrix-master/gifDirectory/" + gif + "/" + str(n) + ".jpg") pict.load() # Must do this before SetImage() calls matrix.SetImage(pict.im.id, 31, 0) time.sleep(gifSpeed * 0.01)
def add_latlon_labels(self, **kwargs): """Add lat/lon labels along upper and left side Compute step of lables. Get lat/lon for these labels from latGrid, lonGrid Print lables to PIL in white. **Modifies:** self.pilImg (PIL image), added lat/lon labels Parameters ---------- latGrid : numpy array array with values of latitudes lonGrid : numpy array array with values of longitudes lonTicks : int or list number of lines to draw or locations of gridlines latTicks : int or list number of lines to draw or locations of gridlines **kwargs : dict Any of Figure parameters """ # modify default values self._set_defaults(kwargs) # test availability of grids if (self.latGrid is None or self.lonGrid is None): return draw = ImageDraw.Draw(self.pilImg) font = ImageFont.truetype(self.fontFileName, self.fontSize) # get vectors with ticks based on input latTicks = self._get_auto_ticks(self.latTicks, self.latGrid) lonTicks = self._get_auto_ticks(self.lonTicks, self.lonGrid) # get corresponding lons from upper edge and lats from left edge lonTicksIdx = self._get_tick_index_from_grid(lonTicks, self.lonGrid, 1, self.lonGrid.shape[1]) latTicksIdx = self._get_tick_index_from_grid(latTicks, self.latGrid, self.lonGrid.shape[0], 1) # draw lons lonsOffset = self.lonGrid.shape[1] / len(lonTicksIdx) / 8. for lonTickIdx in lonTicksIdx: lon = self.lonGrid[0, lonTickIdx] draw.text((lonTickIdx + lonsOffset, 0), '%4.2f' % lon, fill=255, font=font) # draw lats latsOffset = self.latGrid.shape[0] / len(latTicksIdx) / 8. for latTickIdx in latTicksIdx: lat = self.latGrid[latTickIdx, 0] draw.text((0, latTickIdx + latsOffset), '%4.2f' % lat, fill=255, font=font)
def fill_bbs(im, bbs, color=255): draw = ImageDraw.Draw(im) for bb in bbs: draw.rectangle(bb, fill=color)
def drawOval(oval, orig, action): img = Image.new('L', (mapSize * 2, mapSize)) draw = ImageDraw.Draw(img) draw.ellipse(oval, fill=action[1]) del draw return action[0](orig, img)
#-*- coding: utf-8 -*- from __future__ import unicode_literals import Image import ImageDraw import time import ImageFont from rgbmatrix import Adafruit_RGBmatrix # Rows and chain length are both required parameters: matrix = Adafruit_RGBmatrix(32, 4) font = ImageFont.load_default() font = ImageFont.truetype("DejaVuSerif.ttf", size=14) text1 = "Reading status" img = Image.new('RGB', (128, 32)) d = ImageDraw.Draw(img) d.text((0, 0), text1, fill=(0, 200, 200), font=font) matrix.SetImage(img.im.id, 0, 0) time.sleep(0.2) text2 = "." img = Image.new('RGB', (128, 32)) d = ImageDraw.Draw(img) d.text((0, 0), text2, fill=(0, 200, 200), font=font) for m in range(1, 6, 1): for n in range(106, 120, 3): matrix.SetImage(img.im.id, n, 0) time.sleep(0.3) time.sleep(2)
def update(epd): # EPD 2 inch 13 b HAT is rotated 90 clockwize and does not support partial update # But has amazing 2 colors print "drawing status" width = epd2in13b.EPD_HEIGHT height = epd2in13b.EPD_WIDTH top = 2 fill_color = 0 xt = 70 xc = 120 xc2 = 164 while True: frame_black = Image.new('1', (width, height), 255) frame_red = Image.new('1', (width, height), 255) pihole_logo_top = Image.open('pihole-bw-80-top.bmp') pihole_logo_bottom = Image.open('pihole-bw-80-bottom.bmp') # pihole_logo = Image.open('monocolo r.bmp') font = ImageFont.truetype( '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf', 10) font_bold = ImageFont.truetype( '/usr/share/fonts/truetype/dejavu/DejaVuSansMono-Bold.ttf', 11) font_title = ImageFont.truetype( '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf', 11) font_title_bold = ImageFont.truetype( '/usr/share/fonts/truetype/dejavu/DejaVuSansMono-Bold.ttf', 11) font_debug = ImageFont.truetype( '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf', 8) # font = ImageFont.truetype('slkscr.ttf', 15) draw_black = ImageDraw.Draw(frame_black) draw_black.rectangle((0, 0, width, height), outline=0, fill=None) ip = subprocess.check_output("hostname -I | cut -d' ' -f1", shell=True).strip() print "ip:", ip host = subprocess.check_output("hostname", shell=True).strip() + ".local" print "host:", host mem_usage = subprocess.check_output(dedent(""" free -m | awk 'NR==2{printf \"Mem: %s/%sMB %.2f%%\", $3,$2,$3*100/$2 }' """).strip(), shell=True).replace("Mem: ", "") print "memory usage:", mem_usage disk = subprocess.check_output(dedent(""" df -h | awk '$NF==\"/\"{printf \"Disk: %d/%dGB %s\", $3,$2,$5}' """).strip(), shell=True).replace("Disk: ", "") print "disk:", disk try: r = requests.get(api_url) data = json.loads(r.text) dnsqueries = data['dns_queries_today'] adsblocked = data['ads_blocked_today'] clients = data['unique_clients'] except KeyError: time.sleep(1) continue frame_black.paste(pihole_logo_top, (-8, 2)) frame_red.paste(pihole_logo_bottom, (-8, 2)) draw_red = ImageDraw.Draw(frame_red) draw_red.text((10, height - 21), "Pi", font=font_title, fill=fill_color) draw_red.text((23, height - 21), "-hole", font=font_title_bold, fill=fill_color) draw_black.text((xt, top + 0), "HOST: ", font=font_bold, fill=fill_color) draw_black.text((xc, top + 0), host, font=font, fill=fill_color) draw_black.text((xt, top + 15), "IP: ", font=font_bold, fill=fill_color) draw_black.text((xc, top + 15), str(ip), font=font, fill=fill_color) draw_black.text((xt, top + 30), "Mem:", font=font_bold, fill=fill_color) draw_black.text((xc, top + 30), str(mem_usage), font=font, fill=fill_color) draw_black.text((xt, top + 45), "Disk:", font=font_bold, fill=fill_color) draw_black.text((xc, top + 45), str(disk), font=font, fill=fill_color) draw_black.text((xt, top + 60), "Ads Blocked: ", font=font_bold, fill=fill_color) draw_black.text((xc2, top + 60), str(adsblocked), font=font, fill=fill_color) draw_black.text((xt, top + 75), "Clients:", font=font_bold, fill=fill_color) draw_black.text((xc2, top + 75), str(clients), font=font, fill=fill_color) draw_black.text((xt, top + 90), "DNS Queries: ", font=font_bold, fill=fill_color) draw_black.text((xc2, top + 90), str(dnsqueries), font=font, fill=fill_color) draw_black.text((14, height - 10), u"↻: ", font=font, fill=fill_color) draw_black.text((24, height - 8), strftime("%H:%M", gmtime()), font=font_debug, fill=fill_color) epd.display_frame( epd.get_frame_buffer(frame_black.transpose(PIL.Image.ROTATE_90)), epd.get_frame_buffer(frame_red.transpose(PIL.Image.ROTATE_90))) sleep_sec = 10 * 60 print "sleeping {0} sec ({1} min) at {1}".format( sleep_sec, sleep_sec / 60, strftime("%H:%M", gmtime())) epd.sleep() epd.delay_ms(sleep_sec * 1000) # awakening the display epd.init()
def makeGeometry(self): # parse input file and plot enrichments and gad percents print 'parsing casmo input...' logfile = open(self.input_file, 'r').readlines() self.pin_type = numpy.zeros(shape=(10, 10)) self.pin_num = numpy.zeros(shape=(10, 10)) counter = 0 for line in logfile: if 'LFU' in line: line_num = 0 for i in range(counter + 1, counter + 11): char_num = 0 for j in range(0, line_num + 1): if logfile[i][char_num + 1] == ' ': self.pin_type[line_num, j] = float(logfile[i][char_num]) char_num += 2 else: self.pin_type[line_num, j] = float(logfile[i][char_num] + logfile[i][char_num + 1]) char_num += 3 line_num += 1 if 'LPI' in line: line_num = 0 for i in range(counter + 1, counter + 11): char_num = 0 for j in range(0, line_num + 1): self.pin_num[line_num, j] = float(logfile[i][char_num]) char_num += 2 line_num += 1 counter += 1 # fill in empty pin_types nad pin_nums for row in range(0, 10): for col in range(row, 10): self.pin_type[row, col] = self.pin_type[col, row] self.pin_num[row, col] = self.pin_num[col, row] ''' This portion of the code parses the 'bwr.inp' input file for casmo to find the number of each pin type, the enrichment for each pin type. It uses this information to compute the total cost for the BWR fuel bundle represented by the casmo input file using current fuel costs from the UxC website. ''' # parse bwr.inp and find the ids Gd and non-Gd pins logfile = open(self.input_file, "r").readlines() start_pins = 'FUE' end_pins = 'LFU' Gd_pin = '64016=' # Dictionaries of pin IDs (keys) to uranium enrichments (values) self.non_Gd_pin_IDs_to_enr = {} self.Gd_pin_IDs_to_enr = {} # Dictionaries of pin IDs (keys) to pin quantities (values) self.non_Gd_pin_IDs_to_qty = {} self.Gd_pin_IDs_to_qty = {} self.pin_IDs_to_gad = {} line_counter = 0 for line in logfile: if start_pins in line: while start_pins in line: if Gd_pin in line: # First set the number of this given pin to zero - count pins on next loop in script self.Gd_pin_IDs_to_qty[(int( logfile[line_counter].split()[1]))] = 0 # Next set the enrichment for this pin type self.Gd_pin_IDs_to_enr[(int( logfile[line_counter].split()[1]))] = float( logfile[line_counter].split()[2] [5:len(logfile[line_counter].split()[2])]) # Next set the gad concentration for this pin type self.pin_IDs_to_gad[(int( logfile[line_counter].split()[1]))] = float( logfile[line_counter].split()[3][6:8]) else: # First set number of this given pin to zero - count pins on next loop in script self.non_Gd_pin_IDs_to_qty[(int( logfile[line_counter].split()[1]))] = 0 # Next set the enrichment for this pin type self.non_Gd_pin_IDs_to_enr[(int( logfile[line_counter].split()[1]))] = float( logfile[line_counter].split()[2] [5:len(logfile[line_counter].split()[2])]) # Next set the gad concentration for this pin type self.pin_IDs_to_gad[(int( logfile[line_counter].split()[1]))] = 0.0 line_counter += 1 line = logfile[line_counter] break line_counter += 1 # parse bwr.inp and find the quantity of each pin type in the geometry logfile = open(self.input_file, "r").readlines() start_geometry = 'LFU' end_geometry = 'DEP' num_non_Gd_pins = 0 num_Gd_pins = 0 line_counter = 0 for line in logfile: if start_geometry in line: line_counter += 1 line = logfile[line_counter] while end_geometry not in line: pin_IDs = logfile[line_counter].split() for id in pin_IDs: if int(id) in self.Gd_pin_IDs_to_qty.iterkeys(): self.Gd_pin_IDs_to_qty[int(id)] += 1 num_Gd_pins += 1 else: self.non_Gd_pin_IDs_to_qty[int(id)] += 1 num_non_Gd_pins += 1 line_counter += 1 line = logfile[line_counter] break line_counter += 1 # plot enrichments and gad conc. self.pin_enr = numpy.zeros(shape=(10, 10)) self.pin_gad = numpy.zeros(shape=(10, 10)) for row in range(0, 10): for col in range(0, 10): self.pin_gad[row, col] = self.pin_IDs_to_gad[int( self.pin_type[row, col])] if self.pin_gad[row, col] == 0: self.pin_enr[row, col] = self.non_Gd_pin_IDs_to_enr[int( self.pin_type[row, col])] else: self.pin_enr[row, col] = self.Gd_pin_IDs_to_enr[int( self.pin_type[row, col])] # create array of normalized pin powers to plot gad_max = 10 enr_max = 4.9 self.pin_enr[3, 5] = 0.0 self.pin_enr[4, 5] = 0.0 self.pin_enr[3, 6] = 0.0 self.pin_enr[4, 6] = 0.0 self.pin_enr[5, 3] = 0.0 self.pin_enr[5, 4] = 0.0 self.pin_enr[6, 3] = 0.0 self.pin_enr[6, 4] = 0.0 pin_enr_draw = self.pin_enr / enr_max pin_gad_draw = self.pin_gad / gad_max # create image img_enr = Image.new('RGB', (1000, 1000), 'white') img_gad = Image.new('RGB', (1000, 1000), 'white') draw_enr = ImageDraw.Draw(img_enr) draw_gad = ImageDraw.Draw(img_gad) for i in range(0, 10): for j in range(0, 10): # get color for enr pins if (pin_enr_draw[i, j] <= 1.0 / 3.0): red_enr = 0.0 green_enr = 3.0 * pin_gad_draw[i, j] blue_enr = 1.0 elif (pin_enr_draw[i, j] <= 2.0 / 3.0): red_enr = 3.0 * pin_enr_draw[i, j] - 1.0 green_enr = 1.0 blue_enr = -3.0 * pin_enr_draw[i, j] + 2.0 else: red_enr = 1.0 green_enr = -3.0 * pin_enr_draw[i, j] + 3.0 blue_enr = 0.0 # get color for gad pins if (pin_gad_draw[i, j] <= 1.0 / 3.0): red_gad = 0.0 green_gad = 3.0 * pin_gad_draw[i, j] blue_gad = 1.0 elif (pin_gad_draw[i, j] <= 2.0 / 3.0): red_gad = 3.0 * pin_gad_draw[i, j] - 1.0 green_gad = 1.0 blue_gad = -3.0 * pin_gad_draw[i, j] + 2.0 else: red_gad = 1.0 green_gad = -3.0 * pin_gad_draw[i, j] + 3.0 blue_gad = 0.0 # convert color to RGB triplet red_enr = int(255 * red_enr) green_enr = int(255 * green_enr) blue_enr = int(255 * blue_enr) # convert color to RGB triplet red_gad = int(255 * red_gad) green_gad = int(255 * green_gad) blue_gad = int(255 * blue_gad) # draw pin and pin power draw_enr.rectangle( [i * 100, j * 100, (i + 1) * 100, (j + 1) * 100], (red_enr, green_enr, blue_enr)) draw_gad.rectangle( [i * 100, j * 100, (i + 1) * 100, (j + 1) * 100], (red_gad, green_gad, blue_gad)) draw_enr.text([i * 100 + 35, j * 100 + 40], str(self.pin_enr[i, j]), (0, 0, 0), font=self.font) draw_gad.text([i * 100 + 35, j * 100 + 40], str(self.pin_gad[i, j]), (0, 0, 0), font=self.font) # save image img_enr.save('enr.png') img_gad.save('gad.png')
def __init__(self, image, size=None, color=None): if not hasattr(image, "im"): image = Image.new(image, size, color) self.draw = ImageDraw.Draw(image) self.image = image self.transform = None
def parseOutput(self): print 'parsing casmo output...' # parse output file and make array of pin powers logfile = open("bwr.out", "r").readlines() summary = 'C A S M O - 4 S U M M A R Y' self.powers = numpy.zeros(shape=(10, 10)) counter = 0 for line in logfile: if summary in line: burnup_str = 'burnup = ' + logfile[counter + 1].split()[2] + ' MWD / kg' keff_str = 'keff = ' + logfile[counter + 1].split()[6] peak_power_str = 'peak power = ' + logfile[counter + 4].split()[6] line_num = 0 for i in range(counter + 5, counter + 15): char_start = 2 for j in range(0, line_num + 1): self.powers[line_num, j] = float(logfile[i][char_start] + logfile[i][char_start + 1] + logfile[i][char_start + 2] + logfile[i][char_start + 3] + logfile[i][char_start + 4]) char_start += 7 line_num += 1 # fill in empty pin powers for row in range(0, 10): for col in range(row, 10): self.powers[row, col] = self.powers[col, row] # create array of normalized pin powers to plot pmax = numpy.max(self.powers) powers_draw = self.powers / pmax # create image img = Image.new('RGB', (1000, 1000), 'white') draw = ImageDraw.Draw(img) for i in range(0, 10): for j in range(0, 10): # get color if (powers_draw[i, j] <= 1.0 / 3.0): red = 0.0 green = 3.0 * powers_draw[i, j] blue = 1.0 elif (powers_draw[i, j] <= 2.0 / 3.0): red = 3.0 * powers_draw[i, j] - 1.0 green = 1.0 blue = -3.0 * powers_draw[i, j] + 2.0 else: red = 1.0 green = -3.0 * powers_draw[i, j] + 3.0 blue = 0.0 # convert color to RGB triplet red = int(255 * red) green = int(255 * green) blue = int(255 * blue) # draw pin and pin power draw.rectangle( [i * 100, j * 100, (i + 1) * 100, (j + 1) * 100], (red, green, blue)) draw.text([i * 100 + 25, j * 100 + 40], str(self.powers[i, j]), (0, 0, 0), font=self.font) # save image sum_str = burnup_str + ' ' + keff_str + ' ' + peak_power_str draw.text([250, 5], sum_str, font=self.font) if float(logfile[counter + 1].split()[2]) / 10 < 1.0: img_str = 'pin_powers0' + logfile[counter + 1].split()[2] + '.png' else: img_str = 'pin_powers' + logfile[counter + 1].split()[2] + '.png' img.save(img_str) counter += 1
def clear(self): self.drawing_area.delete("all") self.image=Image.new("RGB",(200,200),(255,255,255)) self.draw=ImageDraw.Draw(self.image)
def makemap(self): sizex=256*(abs(self.bound2.x-self.bound1.x)+1) sizey=256*(abs(self.bound2.y-self.bound1.y)+1) size=(sizex,sizey) back=Image.new("RGB",size) draw=ImageDraw.Draw(back) for x in range(self.bound1.x,self.bound2.x+1): for y in range(self.bound1.y,self.bound2.y+1): for layer in self.layers: f=open(layer+"/"+str(self.zoom)+"/"+str(x)+"/"+str(y)+".png") ol=Image.open(f) posx=x/self.bound1.x*sizex posy=x/self.bound1.x*sizex #ol.convert("RGBA") back.paste(ol,((x-self.bound1.x)*256,(y-self.bound1.y)*256),ol) f.close() #for label in self.labels: for x in self.label: posx=x[2][0] posy=x[2][1] bd=getTile(self.zoom,posx,posy) posxx=(bd.x-self.bound1.x)*256+int(bd.xpx) posyy=(bd.y-self.bound1.y)*256+int(bd.ypx) if x[0]=="city": font = ImageFont.truetype("DejaVuSans-Bold.ttf", 7+pow(self.zoom-7,2)*2) coef=self.zoom/2 draw.polygon(((posxx+coef,posyy+coef),(posxx+coef,posyy-coef),(posxx-coef,posyy-coef),(posxx-coef,posyy+coef)),fill=(255,0,0,255)) w, h = draw.textsize(x[1],font=font) draw.text((posxx-w/2,posyy-h-coef),x[1].decode("utf8"),(0,0,0,255),font=font) if x[0]=="town": font = ImageFont.truetype("DejaVuSans.ttf", 8+pow(self.zoom-8,2)) coef=self.zoom/4 draw.polygon(((posxx+coef,posyy+coef),(posxx+coef,posyy-coef),(posxx-coef,posyy-coef),(posxx-coef,posyy+coef)),fill=(255,129,235,255)) w, h = draw.textsize(x[1],font=font) draw.text((posxx-w/2,posyy-h-coef),x[1].decode("utf8"),(0,0,0,255),font=font) if x[0]=="village": font = ImageFont.truetype("DejaVuSans.ttf", 10+pow(self.zoom-10,2)) coef=self.zoom/8 draw.polygon(((posxx+coef,posyy+coef),(posxx+coef,posyy-coef),(posxx-coef,posyy-coef),(posxx-coef,posyy+coef)),fill=(255,129,235,255)) w, h = draw.textsize(x[1],font=font) draw.text((posxx-w/2,posyy-h-coef),x[1].decode("utf8"),(0,0,0,255),font=font) if x[0]=="camp": font = ImageFont.truetype("DejaVuSans.ttf", 9+pow(self.zoom-9,2)) coef=self.zoom/4 #if len(x[1])>10: # towrite=x[1].decode("utf8")[0:15]+"-" #else: # towrite=x[1] towrite="Primitiv" draw.polygon(((posxx+coef,posyy+coef),(posxx-coef,posyy+coef),(posxx,posyy-coef)),fill=(0,130,0,255)) w, h = draw.textsize(towrite,font=font) draw.text((posxx-w/2,posyy-h-coef),towrite,(0,130,0,255),font=font) #f1=open(self.layer1+"/"+str(self.zoom)+"/"+str(x)+"/"+str(y)+".png") #f2=open(self.layer2+"/"+str(self.zoom)+"/"+str(x)+"/"+str(y)+".png") #ol1=Image.open(f1) #ol2=Image.open(f2) #posx=x/self.bound1.x*sizex #posy=x/self.bound1.x*sizex #ol1.convert("RGBA") #back.paste(ol1,((x-self.bound1.x)*256,(y-self.bound1.y)*256)) #ol2.convert("RGBA") #back.paste(ol2,((x-self.bound1.x)*256,(y-self.bound1.y)*256),ol2) # #f1.close() #f2.close() back.show() back.save(self.result)
def _init(self, code): size = self.calculate_size(len(code[0]), len(code), self.dpi) self._image = Image.new('RGB', size, self.background) self._draw = ImageDraw.Draw(self._image)
def drawBkg(self): if self.bw: self.bkgclr = (255, 255, 255) else: self.bkgclr = self.options.clrbackground self.SetBackgroundColour(self.bkgclr) tableclr = self.options.clrtable if self.bw: tableclr = (0, 0, 0) img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.bkgclr) draw = ImageDraw.Draw(img) BOR = commonwnd.CommonWnd.BORDER txtclr = (0, 0, 0) if not self.bw: txtclr = self.options.clrtexts x = BOR y = BOR draw.line((x + self.SMALL_CELL_WIDTH, y, x + self.TABLE_WIDTH, y), fill=tableclr) y += self.LINE_HEIGHT for i in range(self.LINE_NUM + 1): draw.line((x, y + i * self.LINE_HEIGHT, x + self.TABLE_WIDTH, y + i * self.LINE_HEIGHT), fill=tableclr) draw.line((x, y, x, y + self.TABLE_HEIGHT - self.LINE_HEIGHT), fill=tableclr) x += self.SMALL_CELL_WIDTH y -= self.LINE_HEIGHT draw.line((x, y, x, y + self.TABLE_HEIGHT), fill=tableclr) for i in range(self.COLUMN_NUM + 2): draw.line((x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH, y, x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH, y + self.TABLE_HEIGHT), fill=tableclr) for i in range(astrology.SE_SATURN + 1): clr = (0, 0, 0) if not self.bw: if self.options.useplanetcolors: clr = self.options.clrindividual[i] else: dign = self.chart.dignity(i) clr = self.clrs[dign] txt = common.common.Planets[i] w, h = draw.textsize(txt, self.fntMorinus) draw.text( (x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + (self.LINE_HEIGHT - h) / 2), txt, fill=clr, font=self.fntMorinus) draw.text( (x - self.SMALL_CELL_WIDTH + (self.SMALL_CELL_WIDTH - w) / 2, y + (i + 1) * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=clr, font=self.fntMorinus) plon = self.chart.planets.planets[i].data[planets.Planet.LONG] self.drawLong(draw, x, y + self.TITLE_HEIGHT + i * self.LINE_HEIGHT, plon, clr) for j in range(astrology.SE_SATURN + 1): if j == astrology.SE_SUN or j == astrology.SE_MOON: txt = self.chart.almutens.essentials.essentials[i][j][0] w, h = draw.textsize(txt, self.fntText) draw.text( (x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + (j + 1) * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) else: txt = self.chart.almutens.essentials.essentials2[i][j - 2][0] w, h = draw.textsize(txt, self.fntText) draw.text( (x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + (j + 1) * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) txt = self.chart.almutens.essentials.essentials[i][3][0] w, h = draw.textsize(txt, self.fntText) draw.text((x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + 8 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) txt = self.chart.almutens.essentials.essentials[i][4][0] w, h = draw.textsize(txt, self.fntText) draw.text((x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + 9 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) txt = self.chart.almutens.essentials.essentials[i][2][0] w, h = draw.textsize(txt, self.fntText) draw.text((x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + 10 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) txt = self.chart.almutens.essentials.essentialsmc[i][0] w, h = draw.textsize(txt, self.fntText) draw.text((x + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + 11 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) #Degree Wins txt = mtexts.txts['Almuten'] w, h = draw.textsize(txt, self.fntText) draw.text((x + self.LONGITUDE_CELL_WIDTH + 7 * self.CELL_WIDTH + (self.DEGREEWINS_CELL_WIDTH - w) / 2, y + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT # num = len(self.chart.almutens.essentials.degwinner) for i in range(2): self.drawDegWinner(draw, x + self.LONGITUDE_CELL_WIDTH, y, i, False, self.chart.almutens.essentials.degwinner, txtclr) x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT + 2 * self.LINE_HEIGHT num = len(self.chart.almutens.essentials.degwinner2) for i in range(num): self.drawDegWinner(draw, x + self.LONGITUDE_CELL_WIDTH, y, i, False, self.chart.almutens.essentials.degwinner2, txtclr) x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT + 7 * self.LINE_HEIGHT self.drawDegWinner(draw, x + self.LONGITUDE_CELL_WIDTH, y, 3, True, self.chart.almutens.essentials.degwinner, txtclr) x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT + 8 * self.LINE_HEIGHT self.drawDegWinner(draw, x + self.LONGITUDE_CELL_WIDTH, y, 4, True, self.chart.almutens.essentials.degwinner, txtclr) x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT + 9 * self.LINE_HEIGHT self.drawDegWinner(draw, x + self.LONGITUDE_CELL_WIDTH, y, 2, True, self.chart.almutens.essentials.degwinner, txtclr) x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT + 10 * self.LINE_HEIGHT self.drawDegWinner2(draw, x + self.LONGITUDE_CELL_WIDTH, y, self.chart.almutens.essentials.degwinnermc, txtclr) x = BOR y = BOR + self.LINE_HEIGHT #LoF clr = (0, 0, 0) if not self.bw: if self.options.useplanetcolors: clr = self.options.clrindividual[11] else: clr = self.options.clrperegrin txt = common.common.fortune w, h = draw.textsize(txt, self.fntMorinus) draw.text( (x + (self.SMALL_CELL_WIDTH - w) / 2, y + 7 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=clr, font=self.fntMorinus) flon = self.chart.fortune.fortune[fortune.Fortune.LON] self.drawLong(draw, x + self.SMALL_CELL_WIDTH, y + 7 * self.LINE_HEIGHT, flon, clr) #Syzygy txt = mtexts.txts['Syzygy'] w, h = draw.textsize(txt, self.fntText) draw.text( (x + (self.SMALL_CELL_WIDTH - w) / 2, y + 8 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) slon = self.chart.syzygy.lon self.drawLong(draw, x + self.SMALL_CELL_WIDTH, y + 8 * self.LINE_HEIGHT, slon, txtclr) #Asc txt = mtexts.txts['Asc'] w, h = draw.textsize(txt, self.fntText) draw.text( (x + (self.SMALL_CELL_WIDTH - w) / 2, y + 9 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) alon = self.chart.houses.ascmc[houses.Houses.ASC] self.drawLong(draw, x + self.SMALL_CELL_WIDTH, y + 9 * self.LINE_HEIGHT, alon, txtclr) #MC txt = mtexts.txts['MC'] w, h = draw.textsize(txt, self.fntText) draw.text( (x + (self.SMALL_CELL_WIDTH - w) / 2, y + 10 * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) mlon = self.chart.houses.ascmc[houses.Houses.MC] self.drawLong(draw, x + self.SMALL_CELL_WIDTH, y + 10 * self.LINE_HEIGHT, mlon, txtclr) y = BOR + self.LINE_HEIGHT #Housecusps hcstxt = [ mtexts.txts['HC1'], mtexts.txts['HC2'], mtexts.txts['HC3'], mtexts.txts['HC4'], mtexts.txts['HC5'], mtexts.txts['HC6'], mtexts.txts['HC7'], mtexts.txts['HC8'], mtexts.txts['HC9'], mtexts.txts['HC10'], mtexts.txts['HC11'], mtexts.txts['HC12'] ] for i in range(astrology.SE_SATURN + 1): for j in range(houses.Houses.HOUSE_NUM): if i == 0: txt = hcstxt[j] w, h = draw.textsize(txt, self.fntText) draw.text( (x + (self.SMALL_CELL_WIDTH - w) / 2, y + 11 * self.LINE_HEIGHT + j * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) txt = self.chart.almutens.essentials.essentialshcs[i][j][0] w, h = draw.textsize(txt, self.fntText) draw.text( (x + self.SMALL_CELL_WIDTH + self.LONGITUDE_CELL_WIDTH + i * self.CELL_WIDTH + (self.CELL_WIDTH - w) / 2, y + 11 * self.LINE_HEIGHT + j * self.LINE_HEIGHT + (self.LINE_HEIGHT - h) / 2), txt, fill=txtclr, font=self.fntText) if i == 0: hlon = self.chart.houses.cusps[j + 1] if self.options.ayanamsha != 0 and self.options.hsys != 'W': hlon -= self.chart.ayanamsha hlon = util.normalize(hlon) self.drawLong( draw, x + self.SMALL_CELL_WIDTH, y + 11 * self.LINE_HEIGHT + j * self.LINE_HEIGHT, hlon, txtclr, False) #Housecusps degwinner x = BOR + self.SMALL_CELL_WIDTH + 7 * self.CELL_WIDTH y = BOR + self.TITLE_HEIGHT + 11 * self.LINE_HEIGHT num = len(self.chart.almutens.essentials.degwinnerhcs) for i in range(num): self.drawDegWinner(draw, x + self.LONGITUDE_CELL_WIDTH, y, i, False, self.chart.almutens.essentials.degwinnerhcs, txtclr) wxImg = wx.EmptyImage(img.size[0], img.size[1]) wxImg.SetData(img.tostring()) self.buffer = wx.BitmapFromImage(wxImg)
def createImageOfAnnotation(sequenceObject, outputFile): '''Creates an image of the annotation, with relative positions of features and their size''' try: import ImageFont, Image, ImageDraw except: print '' print 'Could not import Image or ImageDraw library, no image of result being created.' return False horizontalSize = 1224 verticalSize = 250 red = (255,102,102) green = (0,102,51) bege = (255,178,102) blue = (102,178,255) white = (255,255,255) size = (horizontalSize,verticalSize) # size of the image to create im = Image.new('RGB', size, white) # create the image draw = ImageDraw.Draw(im) # create a drawing object that is # used to draw on the new image n = 1 legenda = [] for gbkFeature in sequenceObject.features: if gbkFeature.type == 'tRNA' or gbkFeature.type == 'CDS' or gbkFeature.type == 'rRNA' or gbkFeature.type == 'D-loop': featureLen = (gbkFeature.location.end - gbkFeature.location.start) + 1 featureRelativeSize = horizontalSize * featureLen / len(sequenceObject.seq) featureRelativeStart = (horizontalSize * gbkFeature.location.start / len(sequenceObject.seq)) + 1 if gbkFeature.location.strand == 1: if n%2 == 0: text_pos = (featureRelativeStart - 1,20) # top-left position of our text else: text_pos = (featureRelativeStart - 1,10) # top-left position of our text else: if n%2 == 0: text_pos = (featureRelativeStart - 1,125) # top-left position of our text else: text_pos = (featureRelativeStart - 1,115) # top-left position of our text for qualifier in gbkFeature.qualifiers: if qualifier == 'product' or qualifier == 'gene': #get feature name text = str(n) #gbkFeature.qualifiers[qualifier] if gbkFeature.qualifiers[qualifier] not in legenda: legenda.append(gbkFeature.qualifiers[qualifier]) if gbkFeature.type == 'rRNA': triangleColor = red elif gbkFeature.type == 'tRNA': triangleColor = bege else: triangleColor = blue module_dir = os.path.dirname(__file__) module_dir = os.path.abspath(module_dir) font_full_path = os.path.join(module_dir, 'fonts/FreeSans.ttf') font = ImageFont.truetype(font_full_path,12) # Now, we'll do the drawing: draw.text(text_pos, text, fill="black", font=font) if gbkFeature.location.strand == 1: draw.polygon([(featureRelativeStart,40), (featureRelativeStart,70), \ (featureRelativeStart + featureRelativeSize,55)],outline=triangleColor, fill=triangleColor) else: draw.polygon([(featureRelativeStart,90), (featureRelativeStart + featureRelativeSize,105), \ (featureRelativeStart + featureRelativeSize,75)],outline=triangleColor, fill=triangleColor) n += 1 nlegenda = 0 legendaString = '' linha = 1 while draw.textsize(legendaString,font=font)[0] < horizontalSize and nlegenda < len(legenda): nlegenda += 1 if draw.textsize(legendaString + str(nlegenda) + '-' + legenda[nlegenda - 1] + ', ',font=font)[0] > horizontalSize: draw.text((0,155 + 20 * (linha - 1)), legendaString, fill="black", font=font) linha += 1 nlegenda -= 1 legendaString = '' elif nlegenda == len(legenda): legendaString += str(nlegenda) + '-' + legenda[nlegenda - 1] draw.text((0,155 + 20 * (linha - 1)), legendaString, fill="black", font=font) break else: legendaString += str(nlegenda) + '-' + legenda[nlegenda - 1] + ', ' draw.text((horizontalSize / 2,verticalSize - 15), sequenceObject.name, fill="black", font=font) del draw # I'm done drawing so I don't need this anymore # now, we tell the image to save as a PNG to the # provided file-like object im.save(outputFile, 'PNG')
def drawFunkyWindGauge(self, gaugeName): """Wind direction gauge generator with shaded background to indicate historic wind directions""" imageWidth = self.gauge_dict.as_int('image_width') imageHeight = self.gauge_dict.as_int('image_height') imageOrigin = (imageWidth / 2, imageHeight / 2) syslog.syslog( syslog.LOG_INFO, """reportengine: Generating %s gauge, (%d x %d)""" % (gaugeName, imageWidth, imageHeight)) labelFontSize = self.gauge_dict[gaugeName].as_int('labelfontsize') archivedb = self._getArchive(self.skin_dict['archive_database']) (data_time, data_value) = archivedb.getSqlVectors( 'windDir', archivedb.lastGoodStamp() - self.gauge_dict[gaugeName].as_int('history') * 60, archivedb.lastGoodStamp(), 300, 'avg') for rec in data_value: syslog.syslog(syslog.LOG_INFO, """reportengine: %s""" % rec) # Number of bins to count wind history into numBins = 16 # One data point recorded every 5 mins for 'history' number of hours numPoints = self.gauge_dict[gaugeName].as_int('history') * 60 / 5 # # Get the wind data # buckets = [0.0] * numBins # 22 July 2013 # # Now looks up historic data using weewx helper functions... Thanks Tom! # archive_db = self.config_dict['StdArchive']['archive_database'] archive = weewx.archive.Archive.open( self.config_dict['Databases'][archive_db]) windDirNow = None windSpeedNow = None for row in archive.genSql( "SELECT windDir, windSpeed FROM archive ORDER BY dateTime DESC LIMIT %d" % numPoints): # This line is occasionally crashing out with error: # TypeError: float() argument must be a string or a number if row[0] is not None: windDir = float(row[0]) if (windDir < 0) or (windDir > 360): syslog.syslog( syslog.LOG_INFO, "drawFunkyWindGauge: %f should be in the range 0-360 degrees", windDir) else: buckets[int(windDir * numBins / 360)] += 1 if windSpeedNow is None: windSpeedNow = float(row[1]) if windDirNow is None: windDirNow = windDir max = maxValue(buckets) buckets = [i / max for i in buckets] # # Draw the gauge # im = Image.new("RGB", (imageWidth, imageHeight), (255, 255, 255)) draw = ImageDraw.Draw(im) if imageWidth < imageHeight: radius = imageWidth * 0.45 else: radius = imageHeight * 0.45 sansFont = ImageFont.truetype( "/usr/share/fonts/truetype/freefont/FreeSans.ttf", labelFontSize) bigSansFont = ImageFont.truetype( "/usr/share/fonts/truetype/freefont/FreeSans.ttf", 20) # Background angle = 0.0 angleStep = 360.0 / numBins for i in range(0, numBins, 1): draw.pieslice( (int(imageOrigin[0] - radius), int(imageOrigin[1] - radius), int(imageOrigin[0] + radius), int(imageOrigin[1] + radius)), int(angle + 90), int(angle + angleStep + 90), fill=(255, int(255 * (1 - buckets[i])), 255)) angle += angleStep # Compass points labels = ['N', 'E', 'S', 'W'] for i in range(0, 4, 1): angle = i * math.radians(90) + math.radians(180) # Major tic startPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.93, imageOrigin[1] + radius * math.cos(angle) * 0.93) endPoint = (imageOrigin[0] - radius * math.sin(angle), imageOrigin[1] + radius * math.cos(angle)) draw.line((startPoint, endPoint), fill=(0, 0, 0)) labelText = labels[i] stringSize = sansFont.getsize(labelText) labelPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.80, imageOrigin[1] + radius * math.cos(angle) * 0.80) labelPoint = (labelPoint[0] - stringSize[0] / 2, labelPoint[1] - stringSize[1] / 2) draw.text(labelPoint, labelText, font=sansFont, fill=(0, 0, 0)) # Minor tic angle += math.radians(45) startPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.93, imageOrigin[1] + radius * math.cos(angle) * 0.93) endPoint = (imageOrigin[0] - radius * math.sin(angle), imageOrigin[1] + radius * math.cos(angle)) draw.line((startPoint, endPoint), fill=(0, 0, 0)) # The needle angle = math.radians(windDirNow) endPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.7, imageOrigin[1] + radius * math.cos(angle) * 0.7) leftPoint = (imageOrigin[0] - radius * math.sin(angle - math.pi * 7 / 8) * 0.2, imageOrigin[1] + radius * math.cos(angle - math.pi * 7 / 8) * 0.2) rightPoint = (imageOrigin[0] - radius * math.sin(angle + math.pi * 7 / 8) * 0.2, imageOrigin[1] + radius * math.cos(angle + math.pi * 7 / 8) * 0.2) midPoint = (imageOrigin[0] - radius * math.sin(angle + math.pi) * 0.1, imageOrigin[1] + radius * math.cos(angle + math.pi) * 0.1) draw.line((leftPoint, endPoint), fill=(3, 29, 219)) draw.line((rightPoint, endPoint), fill=(3, 29, 219)) draw.line((leftPoint, midPoint), fill=(3, 29, 219)) draw.line((rightPoint, midPoint), fill=(3, 29, 219)) # Outline draw.ellipse(((imageOrigin[0] - radius, imageOrigin[1] - radius), (imageOrigin[0] + radius, imageOrigin[1] + radius)), outline=(0, 0, 0)) # Digital value text #degreeSign= u'\N{DEGREE SIGN}' #digitalText = "%d" % windDirNow + degreeSign digitalText = self.formatter.to_ordinal_compass( (windDirNow, "degree_compass", "group_direction")) stringSize = bigSansFont.getsize(digitalText) draw.text((imageOrigin[0] - stringSize[0] / 2, imageOrigin[1] + radius * 0.4 - stringSize[1] / 2), digitalText, font=bigSansFont, fill=(3, 29, 219)) del draw im.save(self.whereToSaveIt + gaugeName + "Gauge.png", "PNG")
def drawGauge(self, gaugeValue, gaugeName): imageWidth = self.gauge_dict.as_int('image_width') imageHeight = self.gauge_dict.as_int('image_height') imageOrigin = (imageWidth / 2, imageHeight / 2) # Check gaugeValue is usable if gaugeValue is None: syslog.syslog( syslog.LOG_INFO, "reportengine: Generating %s gauge, (%d x %d), value = None" % (gaugeName, imageWidth, imageHeight)) digitalText = "N/A" else: syslog.syslog( syslog.LOG_INFO, "reportengine: Generating %s gauge, (%d x %d), value = %.1f" % (gaugeName, imageWidth, imageHeight, gaugeValue)) if gaugeName == "Temperature": # Temparature scale degreeSign = u'\N{DEGREE SIGN}' digitalText = "%.1f" % gaugeValue + degreeSign + "C" elif gaugeName == "Pressure": digitalText = "%d" % gaugeValue + " mbar" elif gaugeName == "Humidity": digitalText = "%d" % gaugeValue + "%" elif gaugeName == "WindSpeed": digitalText = "%.1f" % gaugeValue + " knots" elif gaugeName == "WindGust": digitalText = "%.1f" % gaugeValue + " knots" minValue = self.gauge_dict[gaugeName].as_float('minvalue') maxValue = self.gauge_dict[gaugeName].as_float('maxvalue') majorStep = self.gauge_dict[gaugeName].as_float('majorstep') minorStep = self.gauge_dict[gaugeName].as_float('minorstep') labelFontSize = self.gauge_dict[gaugeName].as_int('labelfontsize') labelFormat = "%d" minAngle = 45 # in degrees maxAngle = 315 im = Image.new("RGB", (imageWidth, imageHeight), (255, 255, 255)) draw = ImageDraw.Draw(im) if imageWidth < imageHeight: radius = imageWidth * 0.45 else: radius = imageHeight * 0.45 # Background if gaugeName == "Temperature": if self.gauge_dict[gaugeName].as_int('history') > 0: numBins = self.gauge_dict[gaugeName].as_int('bins') buckets = self.histogram(gaugeName, "outTemp") angle = float(minAngle) angleStep = (maxAngle - minAngle) / float(numBins) for i in range(0, numBins, 1): draw.pieslice((int(imageOrigin[0] - radius), int(imageOrigin[1] - radius), int(imageOrigin[0] + radius), int(imageOrigin[1] + radius)), int(angle + 90), int(angle + angleStep + 90), fill=(255, int(255 * (1 - buckets[i])), 255)) angle += angleStep draw.ellipse(((imageOrigin[0] - radius, imageOrigin[1] - radius), (imageOrigin[0] + radius, imageOrigin[1] + radius)), outline=(0, 0, 0)) sansFont = ImageFont.truetype( "/usr/share/fonts/truetype/freefont/FreeSans.ttf", labelFontSize) bigSansFont = ImageFont.truetype( "/usr/share/fonts/truetype/freefont/FreeSans.ttf", 20) labelValue = minValue # Major tic marks and scale labels for angle in frange(math.radians(minAngle), math.radians(maxAngle), int(1 + (maxValue - minValue) / majorStep)): startPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.93, imageOrigin[1] + radius * math.cos(angle) * 0.93) endPoint = (imageOrigin[0] - radius * math.sin(angle), imageOrigin[1] + radius * math.cos(angle)) draw.line((startPoint, endPoint), fill=(0, 0, 0)) labelText = str(labelFormat % labelValue) stringSize = sansFont.getsize(labelText) labelPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.80, imageOrigin[1] + radius * math.cos(angle) * 0.80) labelPoint = (labelPoint[0] - stringSize[0] / 2, labelPoint[1] - stringSize[1] / 2) draw.text(labelPoint, labelText, font=sansFont, fill=(0, 0, 0)) #draw.point(labelPoint) labelValue += majorStep # Minor tic marks for angle in frange(math.radians(minAngle), math.radians(maxAngle), int(1 + (maxValue - minValue) / minorStep)): startPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.97, imageOrigin[1] + radius * math.cos(angle) * 0.97) endPoint = (imageOrigin[0] - radius * math.sin(angle), imageOrigin[1] + radius * math.cos(angle)) draw.line((startPoint, endPoint), fill=(0, 0, 0)) # The needle if gaugeValue is not None: angle = math.radians(minAngle + (gaugeValue - minValue) * (maxAngle - minAngle) / (maxValue - minValue)) endPoint = (imageOrigin[0] - radius * math.sin(angle) * 0.7, imageOrigin[1] + radius * math.cos(angle) * 0.7) leftPoint = (imageOrigin[0] - radius * math.sin(angle - math.pi * 7 / 8) * 0.2, imageOrigin[1] + radius * math.cos(angle - math.pi * 7 / 8) * 0.2) rightPoint = (imageOrigin[0] - radius * math.sin(angle + math.pi * 7 / 8) * 0.2, imageOrigin[1] + radius * math.cos(angle + math.pi * 7 / 8) * 0.2) midPoint = (imageOrigin[0] - radius * math.sin(angle + math.pi) * 0.1, imageOrigin[1] + radius * math.cos(angle + math.pi) * 0.1) draw.line((leftPoint, endPoint), fill=(3, 29, 219)) draw.line((rightPoint, endPoint), fill=(3, 29, 219)) draw.line((leftPoint, midPoint), fill=(3, 29, 219)) draw.line((rightPoint, midPoint), fill=(3, 29, 219)) # Digital value text stringSize = bigSansFont.getsize(digitalText) draw.text((imageOrigin[0] - stringSize[0] / 2, imageOrigin[1] + radius * 0.4 - stringSize[1] / 2), digitalText, font=bigSansFont, fill=(3, 29, 219)) del draw im.save(self.whereToSaveIt + gaugeName + "Gauge.png", "PNG")
def load_data(): data = pd.read_csv('bac2012.csv', sep='|', header=0, names = ['name', 'county', 'pos', 'unit', 'retry', 'type', 'special', 'ro1', 'ro2', 'oblig', 'oblig1', 'oblig2', 'choice', 'choice1', 'choice2', 'avg', 'admitted']) admit = data[data['admitted'] >0] print len(admit) admit_county = data[['county', 'admitted']] grouped = admit_county.groupby('county') county_percents = grouped.aggregate(np.average) county_percents = county_percents.sort('admitted') print county_percents harta_jud = Image.open('img/harta_bw3.png') #transform_bw(harta_jud) #harta_jud = harta_jud.convert('1') county_pos = { 'ab' : (140, 130), 'ag' : (210, 210), 'ar' : (100, 130), 'b' : (273, 243), # + if 'bc' : (300, 140), 'bh' : (100, 100), 'bn' : (200, 60), 'br' : (340, 200), 'bt' : (300, 20), 'bv' : (230, 160), 'bz' : (300, 220), 'cj' : (170, 100), 'cl' : (330, 270), 'cs' : (90, 200), 'ct' : (380, 260), 'cv' : (270, 170), 'db' : (240, 220), 'dj' : (160, 260), 'gj' : (150, 210), 'gl' : (350, 160), 'gr' : (260, 270), 'hd' : (120, 160), 'hr' : (240, 100), 'il' : (340, 240), 'is' : (300, 70), 'mh' : (110, 230), 'mm' : (200, 40), 'ms' : (220, 100), 'nt' : (280, 80), 'ot' : (200, 260), 'ph' : (260, 200), 'sb' : (190, 150), 'sj' : (150, 70), 'sm' : (140, 30), 'sv' : (250, 40), 'tl' : (410, 220), 'tm' : (70, 170), 'tr' : (230, 270), 'vl' : (180, 200), 'vn' : (300, 160), 'vs' : (340, 110) } print float(county_percents.loc['ab']) percent_min = float(county_percents.iloc[0]) percent_max = float(county_percents.iloc[-1]) percent_delta = percent_max-percent_min draw = ImageDraw.Draw(harta_jud) font = ImageFont.truetype("/Library/Fonts/Georgia.ttf",12) for k,v in county_pos.items(): (x,y) = v alpha = county_percents.loc[k] ImageDraw.floodfill(harta_jud, (x,y), (int((1-alpha)*255), int(alpha*255), 0)) draw.text((x,y), k, (0, 0, 0), font=font) harta_jud.save("img/a_test.png")