def resizeImage(self): if self.image.size[0] <= self.size[0] and self.image.size[1] <= self.size[1]: method = Image.BICUBIC else: method = Image.LANCZOS if self.opt.stretch: self.image = self.image.resize(self.size, method) elif self.image.size[0] <= self.size[0] and self.image.size[1] <= self.size[1] and not self.opt.upscale: if self.opt.format == 'CBZ': borderw = int((self.size[0] - self.image.size[0]) / 2) borderh = int((self.size[1] - self.image.size[1]) / 2) self.image = ImageOps.expand(self.image, border=(borderw, borderh), fill=self.fill) if self.image.size[0] != self.size[0] or self.image.size[1] != self.size[1]: self.image = ImageOps.fit(self.image, self.size, method=Image.BICUBIC, centering=(0.5, 0.5)) else: if self.opt.format == 'CBZ': ratioDev = float(self.size[0]) / float(self.size[1]) if (float(self.image.size[0]) / float(self.image.size[1])) < ratioDev: diff = int(self.image.size[1] * ratioDev) - self.image.size[0] self.image = ImageOps.expand(self.image, border=(int(diff / 2), 0), fill=self.fill) elif (float(self.image.size[0]) / float(self.image.size[1])) > ratioDev: diff = int(self.image.size[0] / ratioDev) - self.image.size[1] self.image = ImageOps.expand(self.image, border=(0, int(diff / 2)), fill=self.fill) self.image = ImageOps.fit(self.image, self.size, method=method, centering=(0.5, 0.5)) else: hpercent = self.size[1] / float(self.image.size[1]) wsize = int((float(self.image.size[0]) * float(hpercent))) self.image = self.image.resize((wsize, self.size[1]), method) if self.image.size[0] > self.size[0] or self.image.size[1] > self.size[1]: self.image.thumbnail(self.size, Image.LANCZOS)
def put_contour(image, size=1, offset=0, contour_color=0, fill_color=0, opacity=100, include_image=True): if not has_transparency(image): return put_border( image, size, offset, contour_color, fill_color, opacity, include_image) image = image.convert('RGBA') mask = imtools.get_alpha(image) w, h = image.size outer_mask = mask.resize( (w + 2 * (size + offset), h + 2 * (size + offset)), Image.ANTIALIAS) inner_mask = mask.resize( (w + 2 * offset, h + 2 * offset), Image.ANTIALIAS) inner_mask = ImageOps.expand(inner_mask, border=size, fill=0) paste(outer_mask, (255 * opacity) / 100, mask=inner_mask) if include_image: image = ImageOps.expand(image, border=size + offset, fill=(0, 0, 0, 0)) mask = ImageOps.expand(mask, border=size + offset, fill=0) paste(outer_mask, 255, mask=mask) contour = ImageOps.colorize(outer_mask, (255, 255, 255), contour_color) paste(contour, fill_color, mask=inner_mask) if include_image: paste(contour, image, mask=image) contour.putalpha(outer_mask) return contour
def __call__(self, sample): img = sample['image'] mask = sample['label'] # random scale (short edge) short_size = random.randint(int(self.base_size * 0.5), int(self.base_size * 2.0)) w, h = img.size if h > w: ow = short_size oh = int(1.0 * h * ow / w) else: oh = short_size ow = int(1.0 * w * oh / h) img = img.resize((ow, oh), Image.BILINEAR) mask = mask.resize((ow, oh), Image.NEAREST) # pad crop if short_size < self.crop_size: padh = self.crop_size - oh if oh < self.crop_size else 0 padw = self.crop_size - ow if ow < self.crop_size else 0 img = ImageOps.expand(img, border=(0, 0, padw, padh), fill=0) mask = ImageOps.expand(mask, border=(0, 0, padw, padh), fill=0) # random crop crop_size w, h = img.size x1 = random.randint(0, w - self.crop_size) y1 = random.randint(0, h - self.crop_size) img = img.crop((x1, y1, x1 + self.crop_size, y1 + self.crop_size)) mask = mask.crop((x1, y1, x1 + self.crop_size, y1 + self.crop_size)) return {'image': img, 'label': mask}
def border(name_image): #Funcio creada per fer un top5 del rànking creat que escollim mostra = open("../files/ranking_val/"+name_image+".txt",'r') print "Imatge mostra:" imagemostra = Image.open("../TerrassaBuildings900/val/images/168-2743-15592.jpg") y = ImageOps.expand(imagemostra,border=50,fill='blue') plt.figure(1),plt.imshow(y),plt.show() print "\n" print "Rànking mostra:" mostra_val = open("../TerrassaBuildings900/val/annotation.txt",'r') for line in mostra_val: id_im = line[0:line.index("\t")] if str(id_im) == name_image: clase_mostra = line[line.index("\t")+1:line.index("\n")] top = 0 for line in mostra: if top<5: id_image = line[0:line.index("\n")] image_rank = Image.open("../TerrassaBuildings900/train/images/"+id_image+".jpg") mostra_train = open("../TerrassaBuildings900/train/annotation.txt",'r') for lin in mostra_train: id_train = lin[0:lin.index("\t")] if id_train == id_image: clase = lin[lin.index("\t")+1:lin.index("\n")] if clase == clase_mostra: y2 = ImageOps.expand(image_rank,border=50,fill='green') plt.figure(top+2),plt.imshow(y2),plt.show() else: y3 = ImageOps.expand(image_rank,border=50,fill='red') plt.figure(top+2),plt.imshow(y3),plt.show() clase.strip() mostra_train.close() top += 1
def resizeImage(self): if self.opt.bordersColor: fill = self.opt.bordersColor else: fill = self.fill # Set target size if self.opt.quality == 0: size = (self.size[0], self.size[1]) elif self.opt.quality == 1 and not self.opt.stretch and not self.opt.upscale and self.image.size[0] <=\ self.size[0] and self.image.size[1] <= self.size[1]: size = (self.size[0], self.size[1]) elif self.opt.quality == 1: # Forcing upscale to make sure that margins will be not too big if not self.opt.stretch: self.opt.upscale = True size = (self.panelviewsize[0], self.panelviewsize[1]) elif self.opt.quality == 2 and not self.opt.stretch and not self.opt.upscale and self.image.size[0] <=\ self.size[0] and self.image.size[1] <= self.size[1]: # HQ version will not be needed self.noHQ = True return else: size = (self.panelviewsize[0], self.panelviewsize[1]) # If stretching is on - Resize without other considerations if self.opt.stretch: if self.image.size[0] <= size[0] and self.image.size[1] <= size[1]: method = Image.BICUBIC else: method = Image.LANCZOS self.image = self.image.resize(size, method) return # If image is smaller than target resolution and upscale is off - Just expand it by adding margins if self.image.size[0] <= size[0] and self.image.size[1] <= size[1] and not self.opt.upscale: borderw = int((size[0] - self.image.size[0]) / 2) borderh = int((size[1] - self.image.size[1]) / 2) # PV is disabled when source image is smaller than device screen and upscale is off if self.image.size[0] <= self.size[0] and self.image.size[1] <= self.size[1]: self.noPV = True self.image = ImageOps.expand(self.image, border=(borderw, borderh), fill=fill) # Border can't be float so sometimes image might be 1px too small/large if self.image.size[0] != size[0] or self.image.size[1] != size[1]: self.image = ImageOps.fit(self.image, size, method=Image.BICUBIC, centering=(0.5, 0.5)) return # Otherwise - Upscale/Downscale ratioDev = float(size[0]) / float(size[1]) if (float(self.image.size[0]) / float(self.image.size[1])) < ratioDev: diff = int(self.image.size[1] * ratioDev) - self.image.size[0] self.image = ImageOps.expand(self.image, border=(int(diff / 2), 0), fill=fill) elif (float(self.image.size[0]) / float(self.image.size[1])) > ratioDev: diff = int(self.image.size[0] / ratioDev) - self.image.size[1] self.image = ImageOps.expand(self.image, border=(0, int(diff / 2)), fill=fill) if self.image.size[0] <= size[0] and self.image.size[1] <= size[1]: method = Image.BICUBIC else: method = Image.LANCZOS self.image = ImageOps.fit(self.image, size, method=method, centering=(0.5, 0.5)) return
def apply_frame(pixbuf): ''' adds a border at all four edges ''' width,height = pixbuf.get_width(),pixbuf.get_height() y = ImageOps.expand(Image.frombytes(K.ImageConstants.RGB_SHORT_NAME,(width,height),pixbuf.get_pixels() ) ,border=22,fill='black') y = ImageOps.expand(y ,border=42,fill='silver') y = ImageOps.expand(y ,border=4,fill='black') return I.fromImageToPixbuf(y)
def draw_histogram(pixbuf, height=170, fill=170, text=True): """Draw a histogram from <pixbuf> and return it as another pixbuf. The returned prixbuf will be 262x<height> px. The value of <fill> determines the colour intensity of the filled graphs, valid values are between 0 and 255. If <text> is True a label with the maximum pixel value will be added to one corner. """ im = Image.new('RGB', (258, height - 4), (30, 30, 30)) hist_data = image.pixbuf_to_pil(pixbuf).histogram() maximum = max(hist_data[:768] + [1]) y_scale = float(height - 6) / maximum r = [int(hist_data[n] * y_scale) for n in xrange(256)] g = [int(hist_data[n] * y_scale) for n in xrange(256, 512)] b = [int(hist_data[n] * y_scale) for n in xrange(512, 768)] im_data = im.getdata() # Draw the filling colours for x in xrange(256): for y in xrange(1, max(r[x], g[x], b[x]) + 1): r_px = y <= r[x] and fill or 0 g_px = y <= g[x] and fill or 0 b_px = y <= b[x] and fill or 0 im_data.putpixel((x + 1, height - 5 - y), (r_px, g_px, b_px)) # Draw the outlines for x in xrange(1, 256): for y in range(r[x-1] + 1, r[x] + 1) + [r[x]] * (r[x] != 0): r_px, g_px, b_px = im_data.getpixel((x + 1, height - 5 - y)) im_data.putpixel((x + 1, height - 5 - y), (255, g_px, b_px)) for y in range(r[x] + 1, r[x-1] + 1): r_px, g_px, b_px = im_data.getpixel((x, height - 5 - y)) im_data.putpixel((x, height - 5 - y), (255, g_px, b_px)) for y in range(g[x-1] + 1, g[x] + 1) + [g[x]] * (g[x] != 0): r_px, g_px, b_px = im_data.getpixel((x + 1, height - 5 - y)) im_data.putpixel((x + 1, height - 5 - y), (r_px, 255, b_px)) for y in range(g[x] + 1, g[x-1] + 1): r_px, g_px, b_px = im_data.getpixel((x, height - 5 - y)) im_data.putpixel((x, height - 5 - y), (r_px, 255, b_px)) for y in range(b[x-1] + 1, b[x] + 1) + [b[x]] * (b[x] != 0): r_px, g_px, b_px = im_data.getpixel((x + 1, height - 5 - y)) im_data.putpixel((x + 1, height - 5 - y), (r_px, g_px, 255)) for y in range(b[x] + 1, b[x-1] + 1): r_px, g_px, b_px = im_data.getpixel((x, height - 5 - y)) im_data.putpixel((x, height - 5 - y), (r_px, g_px, 255)) if text: maxstr = 'max: ' + str(maximum) draw = ImageDraw.Draw(im) draw.rectangle((0, 0, len(maxstr) * 6 + 2, 10), fill=(30, 30, 30)) draw.text((2, 0), maxstr, fill=(255, 255, 255)) im = ImageOps.expand(im, 1, (80, 80, 80)) im = ImageOps.expand(im, 1, (0, 0, 0)) return image.pil_to_pixbuf(im)
def put_border(image, size, offset, contour_color, fill_color, opacity, include_image): if opacity < 100: fill_color = HTMLColorToRGBA(fill_color, (255 * opacity) / 100) if not include_image: w, h = image.size image = Image.new('RGBA', (w + 2 * offset, h + 2 * offset), fill_color) else: image = image.convert('RGBA') image = ImageOps.expand(image, border=offset, fill=fill_color) image = ImageOps.expand(image, border=size, fill=contour_color) return image
def run(self): self.output().makedirs() image_urls = [] country = self.measure.split('.')[0] for center, zoom, boundary in self.CENTER_ZOOM_BOUNDS[country]: lon, lat = center if country == 'uk': image_size = (300, 700, ) else: image_size = (500, 500, ) config = self._generate_config(zoom, lon, lat, boundary) named_map = self.get_named_map(config['layers']) image_urls.append('{cartodb_url}/api/v1/map/static/center/' \ '{layergroupid}/{zoom}/{center_lon}/{center_lat}/{x}/{y}.png'.format( cartodb_url=os.environ['CARTODB_URL'], layergroupid=named_map['layergroupid'], zoom=zoom, center_lon=lon, center_lat=lat, x=image_size[0], y=image_size[1], )) url1 = image_urls.pop(0) print url1 file1 = StringIO(requests.get(url1, stream=True).content) image1 = ImageOps.expand(Image.open(file1), border=10, fill='white') for url2 in image_urls: print url2 file2 = StringIO(requests.get(url2, stream=True).content) image2 = ImageOps.expand(Image.open(file2), border=10, fill='white') (width1, height1) = image1.size (width2, height2) = image2.size result_width = width1 + width2 result_height = max(height1, height2) result = Image.new('RGB', (result_width, result_height)) result.paste(im=image1, box=(0, 0)) result.paste(im=image2, box=(width1, 0)) image1 = result image1.save(self.output().path)
def createPNG(self, filename=None): self.format = 'png' self.backend = 'eps' self.writeTemp(fp=filename) # do not need extension here lilyFile = self.runThroughLily() if noPIL is False: try: lilyImage = Image.open(lilyFile) lilyImage2 = ImageOps.expand(lilyImage, 10, 'white') if os.name == 'nt': format = 'png' # why are we changing format for darwin? -- did not work before elif sys.platform == 'darwin': format = 'jpeg' else: # default for all other platforms format = 'png' if lilyImage2.mode == "I;16": # @PIL88 @PIL101 # "I;16" isn't an 'official' mode, but we still want to # provide a simple way to show 16-bit images. base = "L" else: base = Image.getmodebase(lilyImage2.mode) if base != lilyImage2.mode and lilyImage2.mode != "1": file = lilyImage2.convert(base)._dump(format=format) else: file = lilyImage2._dump(format=format) return file except: raise return lilyFile
def _CompositePackedImages(self, outputPath, size, padding, packedImageDict): # Keep track of the result. result = True # Create the output image. outImage = Image.new("RGBA", size) # Composite all packed images into the output image. for packedImagePath, packedImageData in packedImageDict.iteritems(): try: # Open the image image = Image.open(packedImageData[0].path) # Make sure it's an RGBA image. if image.mode != "RGBA": image = image.convert("RGBA") # Crop the image to its bounding box. image = image.crop(packedImageData[0].boundingBox) # Pad the image. image = ImageOps.expand(image, padding, 0) # Paste the image into the output image. outImage.paste(image, packedImageData[1].packPosition) except IOError: result = False # Save the output image outImage.save(outputPath) return result
def pad(img, padding, fill=0): """Pad the given PIL Image on all sides with the given "pad" value. Args: img (PIL Image): Image to be padded. padding (int or tuple): Padding on each border. If a single int is provided this is used to pad all borders. If tuple of length 2 is provided this is the padding on left/right and top/bottom respectively. If a tuple of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. fill: Pixel fill value. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. Returns: PIL Image: Padded image. """ if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) if not isinstance(padding, (numbers.Number, tuple)): raise TypeError('Got inappropriate padding arg') if not isinstance(fill, (numbers.Number, str, tuple)): raise TypeError('Got inappropriate fill arg') if isinstance(padding, collections.Sequence) and len(padding) not in [2, 4]: raise ValueError("Padding must be an int or a 2, or 4 element tuple, not a " + "{} element tuple".format(len(padding))) return ImageOps.expand(img, border=padding, fill=fill)
def pad_to_size(input_img, size, fill_label=0): """Pads image to the size with fill_label if the input image is smaller""" input_size = np.asarray(input_img.size) padded_size = np.asarray(size) difference = padded_size - input_size parts_to_expand = difference > 0 expand_difference = difference * parts_to_expand expand_difference_top_and_left = expand_difference // 2 expand_difference_bottom_and_right = expand_difference - expand_difference_top_and_left # Form the PIL config vector pil_expand_array = np.concatenate( (expand_difference_top_and_left, expand_difference_bottom_and_right) ) processed_img = input_img # Check if we actually need to expand our image. if pil_expand_array.any(): pil_expand_tuple = tuple(pil_expand_array) processed_img = ImageOps.expand(input_img, border=pil_expand_tuple, fill=fill_label) return processed_img
def update_preview(self, widget): if self.item: #get a crop for the preview #box = tuple((int(round(v)) for v in widget.coords(self.item))) box = self.getRealBox() pbox = self.getPreviewBox() if fast_preview: preview = self.image.crop(pbox) # region of interest else: preview = self.imageOrig.crop(box) # region of interest #add black borders for correct aspect ratio #if preview.size[0] > 512: preview.thumbnail(self.image.size, Image.ANTIALIAS) #downscale to preview rez paspect = preview.size[0]/float(preview.size[1]) aspect = self.image.size[0]/float(self.image.size[1]) if paspect < aspect: bbox = (0, 0, int(preview.size[1] * aspect), preview.size[1]) else: bbox = (0, 0, preview.size[0], int(preview.size[0] / aspect)) preview = ImageOps.expand(preview, border=(bbox[2]-preview.size[0], bbox[3]-preview.size[1])) #preview = ImageOps.fit(preview, size=self.image.size, method=Image.ANTIALIAS, bleed=-10.0) #resize to preview rez (if too small) self.preview = preview.resize(self.image.size, Image.ANTIALIAS) self.previewPhoto = ImageTk.PhotoImage(self.preview) self.previewLabel.configure(image=self.previewPhoto) print str(box[2]-box[0])+"x"+str(box[3]-box[1])+"+"+str(box[0])+"+"+str(box[1])
def resize(self, img, width, height, kwargs=None): if kwargs is None: img = img.resize((width, height), Image.ANTIALIAS) else: background = kwargs['background'] if 'background' in kwargs else None mode = kwargs['mode'] if 'mode' in kwargs else None if mode == self.helper.io.image.mode.center: width_new, height_new = (width, height) width_origin, height_origin = img.size width_calc = width_new height_calc = height_origin * width_calc / width_origin if height_calc > height_new: height_calc = height_new width_calc = width_origin * height_calc / height_origin img = img.resize((int(width_calc), int(height_calc)), Image.ANTIALIAS) img = self.helper.io.image.radius(img, **kwargs) img = ImageOps.expand( img, border=(int((width - width_calc) / 2), int((height_new - height_calc) / 2)), fill=background) radius = int(kwargs['radius'] or 0) if 'radius' in kwargs else None if radius: img_empty = Image.new('RGB', (width, height_new), background) img_empty.paste(img, (0, 0), img) img = img_empty img.__dict__['__radius_processed__'] = True return img
def create_img(self): random.seed() self.img = Image.new("RGB", (self.imgWidth, self.imgHeight), "#FFFFFF") draw = ImageDraw.Draw(self.img) for i in range(0, self.numChars): fontSize = random.randint(11,16) font = ImageFont.truetype("imgVerification/resources/DroidSans.ttf", fontSize) if (font > 13): char = random.randint(0,9) else: char = random.randint(1,9) char = str(char) fontWidth, fontHeight = font.getsize(char) self.numString += char xOffset = self.minX + random.randint(3,10) self.minX = xOffset + fontWidth maxY = self.imgHeight - self.borderThick - fontHeight yOffset = random.randint(self.minY, maxY) draw.text((xOffset, yOffset), char, "#000000", font=font) self.img = ImageOps.expand(self.img, border=self.borderThick,fill='#000000')
def border(self, img, border, border_color): if img.mode == 'P': img = img.convert('RGBA') img = ImageOps.expand(img, border=(border, border), fill=border_color) return img
def create(self, output): # scale image self._scale_source_image() # get texts l1, l1_font, w1, h1 = self._get_line(self.line1) l2, l2_font, w2, h2 = self._get_line(self.line2, type="description") # calculate final image size width, height = self.image.size width += self.margin * 2 + 5 height += self.margin * 2 + h1 + h2 + 30 + 5 # add image border self.image = ImageOps.expand(self.image, border=1, fill="white") # create black background self.final_image = Image.new("RGBA", (width, height), "black") self.final_image.paste(self.image, (self.margin, self.margin), self.image) # draw texts self._draw_line(l1, l1_font, self.image.size[1] + self.margin + 10) self._draw_line(l2, l2_font, self.image.size[1] + self.margin + 10 + h1 + 10) # draw footer self._draw_footer() # self generated image self.final_image.save(output) return self.final_image
def process(self): draw = ImageDraw.Draw(self._image) if(self._block_size == 2): draw.rectangle([(0,0),(163,83)],fill=(0,0,0)) else: draw.rectangle([(0,0),(83,83)],fill=(0,0,0)) font = ImageFont.truetype('./08SeoulNamsanB.ttf',size=45) text = self.getLocation() if(self._block_size == 2): if(len(text) == 4): draw.text((38,21),text,font=font) else: draw.text((26,21),text,font=font) else: if(len(text) == 2): draw.text((19,21),text,font=font) else: draw.text((9,21),text,font=font) del draw self._image = ImageOps.expand(self._image,border=1,fill=(0,0,0)) return self
def _border(src: str, width: int, color: str): image, exf = imread(src) image = ImageOps.expand(image, border=width, fill=color) path_base, ext = os.path.splitext(src) new_file_path = '%s_border%s' % (path_base, ext) print('%s --> %s' % (src, new_file_path)) imwrite(image, new_file_path, exf)
def _tf_pil(self, img): """ Letterbox an image to fit in the network """ if self.dataset is not None: net_w, net_h = self.dataset.input_dim else: net_w, net_h = self.dimension im_w, im_h = img.size if im_w == net_w and im_h == net_h: self.scale = None self.pad = None return img # Rescaling if im_w / net_w >= im_h / net_h: self.scale = net_w / im_w else: self.scale = net_h / im_h if self.scale != 1: resample_mode = Image.NEAREST #Image.BILINEAR if self.scale > 1 else Image.ANTIALIAS img = img.resize((int(self.scale*im_w), int(self.scale*im_h)), resample_mode) im_w, im_h = img.size if im_w == net_w and im_h == net_h: self.pad = None return img # Padding img_np = np.array(img) channels = img_np.shape[2] if len(img_np.shape) > 2 else 1 pad_w = (net_w - im_w) / 2 pad_h = (net_h - im_h) / 2 self.pad = (int(pad_w), int(pad_h), int(pad_w+.5), int(pad_h+.5)) img = ImageOps.expand(img, border=self.pad, fill=(self.fill_color,)*channels) return img
def convertImage(self, inputPath, outputPath): r = inputPath path = outputPath for root, dirs, files in os.walk(r): for f in files: if f.endswith('.gif'): if not os.path.exists(path): #Tworzony jest folder wyjsciowy os.makedirs(path) newroot = root.split(r)[1] #Te dwie linijki moga powodowac problemy, dlatego wazne jest, by obrazy do konwersji znajdowaly sie w podfolderach newroot = newroot.split('/')[1] #Podfolder f2 = f.split('.')[0] orgImg = Image.open(root + "/" + f) orgImg = orgImg.convert('L') orgSize = orgImg.size # niech beda tylko kwadratowe obrazy assert orgSize[0] == orgSize[1] assert self.newSize[0] == self.newSize[1] borderSize = int((self.newSize[0] - orgSize[0]) / 2) # dodanie bialej ramki newImg = ImageOps.expand(orgImg, borderSize, 0) # zapisanie wersji bez inwersji newImg.save(path + newroot + f2 + ".pgm") # dodanie wersji z inwersja newImg = ImageOps.invert(newImg) newImg.save(path + newroot + "n" + f2 + ".pgm")
def create_card(card_data, settings): margin = cm_to_pixels(settings['margin']) spacing = cm_to_pixels(settings['spacing']) (card_width_cm, card_height_cm) = settings['card_size'] (card_width_px, card_height_px) = (cm_to_pixels(card_width_cm), cm_to_pixels(card_height_cm)) border_width_px = cm_to_pixels(settings['border_width']) # around each card border_color = settings['border_color'] outline_width = settings['outline_width'] outline_color = settings['outline_color'] size_minus_border = (card_width_px - (border_width_px * 2), card_height_px - (border_width_px * 2)) (width_minus_border, height_minus_border) = size_minus_border card = Image.new("RGB", size_minus_border, "white") #draw_bg(card, width_minus_border, height_minus_border) draw_illustration(card, card_data['pic'], 100, 500, width_minus_border, outline_width, outline_color) draw_title(card, card_data['name'], (20, 15)) draw_body(card, card_data['body'], 730, width_minus_border, card_data['body_width']) draw_footer(card, 100, width_minus_border, height_minus_border) draw_corner_nr(card, card_data['speed'], (width_minus_border - 65, height_minus_border - 90)) card_with_border = ImageOps.expand(card, border=border_width_px, fill=border_color) return card_with_border
def loader(queue, settings): from pyglet.image import ImageData from PIL import Image, ImageOps import random, glob, time displayed = set() last_scan = time.time() files = glob.glob("{}/*jpg".format(settings['originals'])) new = sorted(list(set(files) - displayed)) while 1: if last_scan + 15 < time.time(): last_scan = time.time() files = glob.glob("{}/*jpg".format(settings['originals'])) new = sorted(list(set(files) - displayed))[15:] if new: filename = random.choice(new) displayed.add(filename) else: filename = random.choice(files) image = Image.open(filename) image = image.transpose(Image.FLIP_TOP_BOTTOM) image.thumbnail(settings['large_size'], Image.ANTIALIAS) image = ImageOps.expand(image, border=32, fill=(255, 255, 255)) w, h = image.size image = image.convert() image = ImageData(w, h, image.mode, image.tostring()) queue.put(image)
def to_file(self, f, scale=1, border=0): i = self.to_transparent_image() if scale != 1: i = i.resize((i.size[0] * scale, i.size[1] * scale)) if border: i = ImageOps.expand(i, border) i.save(f)
def apply_border(pixbuf,borderSize,borderColor): ''' adds a border at all four edges ''' width,height = pixbuf.get_width(),pixbuf.get_height() y = ImageOps.expand(Image.frombytes(K.ImageConstants.RGB_SHORT_NAME,(width,height),pixbuf.get_pixels() ) ,border=borderSize,fill=borderColor) return I.fromImageToPixbuf(y)
def draw_illustration(card, illustration_name, y, vertical_space, width_minus_border, outline_width, outline_color): image_spacing = 20 image_spacing_x2 = image_spacing * 2 illustration = Image.open("illustrations/" + illustration_name + ".png") cropped = ImageOps.fit(illustration, (width_minus_border - (outline_width * 2) - image_spacing_x2, vertical_space - (outline_width * 2)), Image.ANTIALIAS, 0.01, (0.5, 0.5)) cropped_with_border = ImageOps.expand(cropped, border=outline_width, fill=outline_color) card.paste(cropped_with_border, (0 + image_spacing, y))
def render_line(self, text): """ Draws a line onto a Cairo surface which will be converted to an pillow Image. Args: text (unicode): A string which will be rendered as a single line. Returns: PIL.Image of mode 'L'. Raises: KrakenCairoSurfaceException if the Cairo surface couldn't be created (usually caused by invalid dimensions. """ temp_surface = cairo.cairo_image_surface_create(0, 0, 0) width, height = _draw_on_surface(temp_surface, self.font, self.language, text) cairo.cairo_surface_destroy(temp_surface) if width == 0 or height == 0: raise KrakenCairoSurfaceException('Surface zero pixels in at least one dimension', width, height) real_surface = cairo.cairo_image_surface_create(0, width, height) _draw_on_surface(real_surface, self.font, self.language, text) data = cairo.cairo_image_surface_get_data(real_surface) size = int(4 * width * height) buffer = ctypes.create_string_buffer(size) ctypes.memmove(buffer, data, size) im = Image.frombuffer("RGBA", (width, height), buffer, "raw", "BGRA", 0, 1) cairo.cairo_surface_destroy(real_surface) im = im.convert('L') im = ImageOps.expand(im, 5, 255) return im
def draw_text_on_logo(line1, line2, output_filename): ''' >>> line1 = u'TOIDUKOGUMISPÄEVAD' >>> line2 = u'9.12 – 10.12' >>> output_filename = '../htdocs/static/generated/test.png' >>> draw_text_on_logo(line1, line2, output_filename) ''' font = ImageFont.truetype(FONT_FILE, 10) logo = Image.open(LOGO_FILE) logo.thumbnail((120, 120)) logo_height = logo.size[1] text_height = font.getsize(line1)[1] left_border = 3 first_line_offset = 2 line_gap = 3 expand = text_height * 2 + line_gap * 2 + first_line_offset canvas = Image.new('RGBA', (logo.size[0], logo.size[1] + expand), 'white') canvas.paste(logo, (0, 0)) draw = ImageDraw.Draw(canvas) first_line_offset = logo_height + first_line_offset draw.text((left_border, first_line_offset), line1, 'black', font=font) second_line_offset = first_line_offset + line_gap + text_height draw.text((left_border, second_line_offset), line2, 'black', font=font) canvas = ImageOps.expand(canvas, border=2, fill='white') _save_file(canvas, output_filename)
def splitImage(self, img): # Get best subsize between 200 and 350 w, h = img.size orig_size = (w, h) if (-w%200)*(-h%200) < (-w%350)*(-h%350): subsize = 200 else: subsize = 350 # Set sizes multiples of subsize n_w = int(numpy.ceil(w/subsize) * subsize) n_h = int(numpy.ceil(h/subsize) * subsize) new_img = Image.new('RGB', (n_w, n_h), 'black') new_img.paste(img, (0,0)) # Add border size new_img = ImageOps.expand(new_img, border=BORDER_SIZE, fill='black') # Split # We want images of size (subsize+2*BORDER_SIZE)x(subsize+2*BORDER_SIZE) imgs = [] images_on_width = int(n_w/subsize) images_on_height = int(n_h/subsize) rdata = (orig_size, subsize, images_on_width, images_on_height) for i in range(images_on_width): for j in range(images_on_height): left = i*subsize right = (i+1)*subsize + 2*BORDER_SIZE top = j*subsize bottom = (j+1)*subsize + 2*BORDER_SIZE simg = new_img.crop((left, top, right, bottom)) imgs.append((simg, (i,j))) return imgs, rdata
def __call__(self, img): return ImageOps.expand(img, border=self.pad, fill=0)
def load_data(): img_array = [] path1 = 'C:\\Flowers Data\\flowers' mypaths = [] x = [] class_num = [] # d = {} # train_data = [] # test_data = [] # re_img = [] # app_n = [] # d1 = {} full_inp_data = [] desired_size = 506 dict_flower = { "daisy": 0, "dandelion": 1, "rose": 2, "sunflower": 3, "tulip": 4 } for f in os.listdir(path1): dirs = os.listdir(path1) s = os.path.join(path1, f) mypaths.append(s) print(mypaths) # print(mypaths) class_num = dirs.index(f) print(class_num) # c = count() # numbers = [d.setdefault(i, next(c)) for i in mypaths] ## print(numbers) # print(" i will execute my loop") # print(c) print(f) assing_val = dict_flower[f] print("assignment val: " + str(assing_val)) for fp in os.listdir(s): # print("second loop") # if os.path.isdir(s): try: # print(fp, 'i got fp') img_data = Image.open((os.path.join(s, fp))) except IOError: pass old_size = img_data.size ratio = float(desired_size) / max(old_size) # print(ratio) new_size = tuple([int(x * ratio) for x in old_size]) """ resizing the image by using image module""" img_data = img_data.resize(new_size, Image.ANTIALIAS) # new_im = Image.new("RGB", (desired_size, desired_size)) # new_im.paste(img_data, ((desired_size-new_size[0])//2, # (desired_size-new_size[1])//2)) """resizing the images by using imageOps module""" delta_w = desired_size - new_size[0] delta_h = desired_size - new_size[1] padding = (delta_w // 2, delta_h // 2, delta_w - (delta_w // 2), delta_h - (delta_h // 2)) new_im = ImageOps.expand(img_data, padding) # print((new_im)) # print(new_im) gs_data = new_im.convert(mode='L') # print(np.shape(gs_data)) data = np.asarray(gs_data) img_array = Image.fromarray(data) # images.append(img_array) # print(np.shape(images)) # images = np.asarray(img_array) # x.append(img_array) inpt = np.array(img_array) # print('Min: %.3f, Max: %.3f' % (inpt.min(), inpt.max())) pixels = asarray(inpt) # print('Data Type: %s' % pixels.dtype) """confirm image range in between 0 to 255""" # print('Min: %.3f, Max: %.3f' % (pixels.min(), pixels.max())) """convert intergers to float""" inpt = pixels.astype('float32') """ normalize to the range 0 to 1""" inpt /= 255.0 """ confirm the normalization""" # print('Min: %.3f, Max: %.3f' % (inpt.min(), inpt.max())) # print(inpt[100]) # break # print(np.shape()) # print(np.shape(inpt)) inpt = np.array([np.reshape(inpt, np.prod(inpt.shape))]) # print("inp: "+str(np.shape(inpt))) outp = vectorized_result(assing_val) # print("out: "+str(np.shape(outp))) x = [inpt, outp] # print(x) # print(np.shape(x)) full_inp_data.append(x) # print("final training data") # full_inp_data = np.array(full_inp_data) print(np.shape(full_inp_data)) training_data, test_data = full_inp_data[:3000], full_inp_data[3000:] print(np.shape(training_data)) print(np.shape(test_data)) # print(np.shape(train_data)) return training_data, test_data #def load_data_wrapper(): # tr_d, te_d= load_data() ## print((tr_d[0])) ## s = len(tr_d) ## print(len(tr_d))S # training_data = [tr_d] # test_data = [te_d] return training_data, test_data
xray = Image.open(dir_xray_png + '/' + file) heatmap = Image.open(dir_heatmap_png + '/' + file) '''Get node_1 from landmark fcsv''' landmarks = get_landmarks(file_name, dir_fcsv) x = -1 * int(float(landmarks['Node_1'][0])) y = -1 * int(float(landmarks['Node_1'][1])) cols, rows = xray.size if x - 512 < 0 or x + 512 > cols or y - 762 < 0 or y + 256 > rows: '''Add border to image''' padding = 768 # give size for margin xray_extended = ImageOps.expand(xray, border=padding, fill=38) # 38 xray black heatmap_extended = ImageOps.expand( heatmap, border=padding, fill='#0C0786') # 0C0786 = plasma blue x += padding y += padding xray_croped = xray_extended.crop((x - 512, y - 768, x + 512, y + 256)) heatmap_croped = heatmap_extended.crop( (x - 512, y - 768, x + 512, y + 256)) else: xray_croped = xray.crop((x - 512, y - 768, x + 512, y + 256)) heatmap_croped = heatmap.crop((x - 512, y - 768, x + 512, y + 256))
def CreateLangLabelImg_fx(lang_rank, lang_name, vote_percent, vote_count, q_name, tmp_imageObj_dict): '''finding Color and finding Logo image''' # addition to lang_rank lang_rank += 1 # finding lang color using Ref table lang_color = colors_ref.at[lang_name, 'color'] # reading Logo os.chdir('.\LanguageInfo') if lang_name == 'C++': lang_logo = Image.open('Cpp.png') elif lang_name == 'C#': lang_logo = Image.open('Csharp.png') else: lang_logo = Image.open(lang_name + '.png') os.chdir('..') '''Logo resizing''' # resizing LangLogo # if WIDE, then scale the height according to width if lang_logo.size[0] > lang_logo.size[1]: # since WIDE, we find the nu_height nuheight_float = (160 / lang_logo.size[0]) * lang_logo.size[1] nuheight_int = round(nuheight_float / 2.0) * 2 # resiziing LangLogo lang_logo = lang_logo.resize((160, nuheight_int)) # if TALL, then scale the width according to the height elif lang_logo.size[1] > lang_logo.size[0]: # since TALL, we find NuWidth nuwidth_float = (160 / lang_logo.size[1]) * lang_logo.size[0] nuwidth_int = round(nuwidth_float / 2.0) * 2 # resizing LangLogo lang_logo = lang_logo.resize((nuwidth_int, 160)) # if neither tall nor wide, then EVEN, and just resize to 280,280 else: lang_logo = lang_logo.resize((160, 160)) '''Title sizing''' # defining Lang Title Str for the #2 current tie if q_name == 'Q2Current' and lang_name in ['Java', 'JavaScript']: lang_title_str = '2 (tie): ' + lang_name # defining the normal Lang Title Str else: lang_title_str = str(lang_rank) + ': ' + lang_name # determing which font number is closest to 80 height for the Title for fsize in np.arange(100, 0, -1): # creating langFont lang_title_fnt = ImageFont.truetype('ARLRDBD.TTF', fsize) # testing if at or below 80, breaking if so if lang_title_fnt.getsize(lang_title_str)[1] <= 110: break # finding the size of the title lang_title_size = lang_title_fnt.getsize(lang_title_str) '''Vote Perc sizing''' # defining Lang VotePerc Str lang_voteperc_str = '{:.1%}'.format(vote_percent) # determing which font number is closest to 50 height for the Percent for fsize in np.arange(100, 0, -1): # creating langFont lang_voteperc_fnt = ImageFont.truetype('ARLRDBD.TTF', fsize) # testing if below 50, breaking if so if lang_voteperc_fnt.getsize(lang_voteperc_str)[1] <= 70: break # defining Lang VotePerc Size lang_voteperc_size = lang_voteperc_fnt.getsize(lang_voteperc_str) '''Vote Count sizing''' # defining Lang VoteCount Str lang_votecount_str = '(' + str(int(vote_count)) + ' votes)' # determing which font number is closest to 30 height for the Count for fsize in np.arange(100, 0, -1): # creating langFont lang_votecount_fnt = ImageFont.truetype('ARLRDBD.TTF', fsize) # testing if below 30, breaking if so if lang_votecount_fnt.getsize(lang_votecount_str)[1] <= 60: break # defining Lang VoteCount Size lang_votecount_size = lang_votecount_fnt.getsize(lang_votecount_str) '''White Background creation''' # determining the width # first, find the longer length between the Title, Perc, and Count farthest_x = max([ lang_title_size[0], lang_voteperc_size[0] + lang_votecount_size[0] + 35 ]) # creating Background Size, picking between Farthest Title or Count for the X width background_size = (farthest_x + 215, 190) # creating white background background_img = Image.new('RGBA', background_size, 'white') # adding border if 'JavaScript' in lang_name or 'SQL' in lang_name: background_img = ImageOps.expand(background_img, border=3, fill=lang_color) background_img = ImageOps.expand(background_img, border=2, fill='#3f3f3f') else: background_img = ImageOps.expand(background_img, border=5, fill=lang_color) '''Pasting Logo''' # pasting LangLogo onto background, creating full image full_img = background_img.copy() # calculating the position of the logo logo_position = (int(20 + (160 - lang_logo.size[0]) / 2), int(20 + (160 - lang_logo.size[1]) / 2)) # try as mask try: full_img.paste(lang_logo, logo_position, mask=lang_logo) # if logo is no mask, paste as normal except ValueError: full_img.paste(lang_logo, logo_position) '''Drawing on Title, Vote Perc, and Vote Count''' # determining Title position lang_title_position = (200, 5) # creating draw object full_draw = ImageDraw.Draw(full_img) # drawing black outlines for JavaScript and SQL if 'JavaScript' in lang_name or 'SQL' in lang_name: for tmp_text_pos, tmp_text_str, tmp_fnt in zip( [(200, 5), (220, 105), (240 + lang_voteperc_size[0], 125)], [lang_title_str, lang_voteperc_str, lang_votecount_str], [lang_title_fnt, lang_voteperc_fnt, lang_votecount_fnt]): for position_tup in ( list( it.product( np.arange(tmp_text_pos[0] - 3, tmp_text_pos[0] + 4), [tmp_text_pos[1] + 1])) + #bottom border list( it.product( np.arange(tmp_text_pos[0] - 1, tmp_text_pos[0] + 2), [tmp_text_pos[1] + 2])) + #bottom border extra list( it.product( np.arange(tmp_text_pos[0] - 3, tmp_text_pos[0] + 4), [tmp_text_pos[1] - 1])) + #top border list( it.product( np.arange(tmp_text_pos[0] - 1, tmp_text_pos[0] + 2), [tmp_text_pos[1] - 2])) + #top border extra list( it.product( [tmp_text_pos[0] - 1], np.arange(tmp_text_pos[1] - 3, tmp_text_pos[1] + 4))) + #left border list( it.product([tmp_text_pos[0] - 2], np.arange(tmp_text_pos[1] - 1, tmp_text_pos[1] + 2))) + #left border extra list( it.product( [tmp_text_pos[0] + 1], np.arange(tmp_text_pos[1] - 3, tmp_text_pos[1] + 4))) + #right border list( it.product( [tmp_text_pos[0] + 2], np.arange(tmp_text_pos[1] - 1, tmp_text_pos[1] + 2)))): #right border extra # drawing black shift full_draw.text(position_tup, tmp_text_str, fill='#3f3f3f', font=tmp_fnt) # drawing colored center for title full_draw.text(lang_title_position, lang_title_str, fill=lang_color, font=lang_title_fnt) # drawing Lang VotePerc full_draw.text((220, 5 + 100), lang_voteperc_str, fill=lang_color, font=lang_voteperc_fnt) # drawing Lang VoteCount full_draw.text((240 + lang_voteperc_size[0], 5 + 120), lang_votecount_str, fill=lang_color, font=lang_votecount_fnt) # adding the image obj to the Dict tmp_imageObj_dict[q_name + '_' + lang_name] = full_img # returning the Image Obj dict return tmp_imageObj_dict
def resize(target_size, img_filepath, save_dir, quality=95, keep_aspect_ratio=True): try: img = Image.open(img_filepath) except Exception as ex: # print(ex) return img_basename = os.path.basename(img_filepath) print(img_basename) img_name, img_ext = os.path.splitext(img_basename) resized_img_name = '{}_resize_{}x{}'.format(img_name, size[0], size[1]) resized_img_basename = resized_img_name + img_ext resized_img_filepath = os.path.join(save_dir, resized_img_basename) original_size = img.size # resize and keep aspect ratio ratio = min(target_size[0] / original_size[0], target_size[1] / original_size[1]) new_size = tuple([int(s * ratio) for s in original_size]) img = img.resize(new_size, Image.BICUBIC) # padding to desired size and save imge delta_w = target_size[0] - new_size[0] delta_h = target_size[1] - new_size[1] padding_left = delta_w // 2 padding_top = delta_h // 2 padding_right = delta_w - padding_left padding_bottom = delta_h - padding_top padding = (padding_left, padding_top, padding_right, padding_bottom) img = ImageOps.expand(img, padding) img.save(resized_img_filepath, quality=quality) # modify annotation and save in json format (change shape to bounding box in rectangle) jsn_filepath = img_filepath.replace(img_ext, '.json') with open(jsn_filepath, 'r') as fp: jsn = json.load(fp) jsn['imageWidth'] = img.size[0] jsn['imageHeight'] = img.size[1] jsn['imagePath'] = resized_img_basename bndboxes = list() labels = list() for shape in jsn['shapes']: labels.append(shape['label']) points = shape['points'] for idx, point in enumerate(points): x, y = point x = int(x * ratio + padding_left) y = int(y * ratio + padding_top) points[idx] = [x, y] ''' # change all shapes to bounding box in rectangle # for example, [xmin, ymin], [xmax, ymax] xmin, ymin, xmax, ymax = bndbox(shape['points']) shape['points'] = [ [xmin, ymin], [xmax, ymax] ] shape['shape_type'] = 'rectangle' ''' resized_jsn_basename = resized_img_name + '.json' resized_jsn_filepath = os.path.join(save_dir, resized_jsn_basename) with open(resized_jsn_filepath, 'w') as fp: json.dump(jsn, fp, indent=4) ## generate xml in pascal voc annotation and save ## collect labels and bounding boxes #labels, bndboxes = list(), list() #for shape in jsn['shapes']: # labels.append(shape['label']) # bndboxes.append(bndbox(shape['points'])) ## generate xml file #resized_xml_basename = resized_img_name + '.xml' #resized_xml_filepath = os.path.join(save_dir, resized_xml_basename) #with open(resized_xml_filepath, 'w') as fp: # fp.write(etree.tostring(xmlgen(resized_img_basename, img.size, labels, bndboxes), encoding='utf-8', pretty_print=True).decode('utf-8')) return labels
def pad(img, padding, fill=0, padding_mode="constant"): r"""Pad the given PIL.Image on all sides with the given "pad" value. Args: img (PIL Image): Image to be padded. padding (int or tuple or list): Padding on each border. If a single int is provided this is used to pad all borders. If a tuple or list of length 2 is provided this is the padding on left/right and top/bottom respectively. If a tuple or list of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. For compatibility reasons with ``functional_tensor.pad``, if a tuple or list of length 1 is provided, it is interpreted as a single int. fill (int or str or tuple): Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. - constant: pads with a constant value, this value is specified with fill - edge: pads with the last value on the edge of the image - reflect: pads with reflection of image (without repeating the last value on the edge) padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2] - symmetric: pads with reflection of image (repeating the last value on the edge) padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3] Returns: PIL Image: Padded image. """ if not _is_pil_image(img): raise TypeError("img should be PIL Image. Got {}".format(type(img))) if not isinstance(padding, (numbers.Number, tuple, list)): raise TypeError("Got inappropriate padding arg") if not isinstance(fill, (numbers.Number, str, tuple)): raise TypeError("Got inappropriate fill arg") if not isinstance(padding_mode, str): raise TypeError("Got inappropriate padding_mode arg") if isinstance(padding, list): padding = tuple(padding) if isinstance(padding, tuple) and len(padding) not in [1, 2, 4]: raise ValueError("Padding must be an int or a 1, 2, or 4 element tuple, not a " + "{} element tuple".format(len(padding))) if isinstance(padding, tuple) and len(padding) == 1: # Compatibility with `functional_tensor.pad` padding = padding[0] if padding_mode not in ["constant", "edge", "reflect", "symmetric"]: raise ValueError("Padding mode should be either constant, edge, reflect or symmetric") if padding_mode == "constant": if isinstance(fill, numbers.Number): fill = (fill,) * len(img.getbands()) if len(fill) != len(img.getbands()): raise ValueError("fill should have the same number of elements " "as the number of channels in the image " "({}), got {} instead".format(len(img.getbands()), len(fill))) if img.mode == "P": palette = img.getpalette() image = ImageOps.expand(img, border=padding, fill=fill) image.putpalette(palette) return image return ImageOps.expand(img, border=padding, fill=fill) else: if isinstance(padding, int): pad_left = pad_right = pad_top = pad_bottom = padding if isinstance(padding, tuple) and len(padding) == 2: pad_left = pad_right = padding[0] pad_top = pad_bottom = padding[1] if isinstance(padding, tuple) and len(padding) == 4: pad_left = padding[0] pad_top = padding[1] pad_right = padding[2] pad_bottom = padding[3] if img.mode == 'P': palette = img.getpalette() img = np.asarray(img) img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode) img = Image.fromarray(img) img.putpalette(palette) return img img = np.asarray(img) # RGB image if len(img.shape) == 3: img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)), padding_mode) # Grayscale image if len(img.shape) == 2: img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode) return Image.fromarray(img)
output = image.crop(area) return output image_name = "egg" image = Image.open(f"{image_name}.png") width, height = image.size size = 128 x_loss = ceil_to_number(width, size) - width y_loss = ceil_to_number(height, size) - height loss = x_loss if y_loss > x_loss: loss = y_loss image = ImageOps.expand(image, border=loss, fill=(255, 255, 255)) x_index = 0 y_index = 0 for x in range(0, ceil_to_number(width, size), size): y_index = 0 for y in range(0, ceil_to_number(height, size), size): slice( image, (x + loss, y + loss), (size, size)).save(f"./tiles/{image_name}_{x_index}_{y_index}.png") y_index = y_index + 1 x_index = x_index + 1 print(int(ceil_to_number(width, size) / size - 1), int(ceil_to_number(height, size) / size - 1))
def images_to_tfrecords(image_names, output_filename, num_images_per_tfrecord, image_class=None, target_size=299): """ This function converts images listed in the image_names to tfrecords files :param image_names: a list of strings like ['xxx.jpg', 'xxx.jpg', 'xxx.jpg', ...] :param output_filename: 'train' :param num_images_per_tfrecord: integer :param image_class: class label for each image, a list like [1, 34, 228, ...] :param target_size: the size of images after padding and resizing :return: """ num_images = len(image_names) # iteratively handle each image writer = None start_time = time.time() for image_index in range(num_images): # retrieve a single image im_loc = os.path.join(FLAGS.DEFAULT_DOWNLOAD, image_names[image_index]) im_cla = image_class[image_index] if isinstance(image_class, list) else None im = Image.open(im_loc) # resize the image old_size = im.size ratio = float(target_size) / max(old_size) if not ratio == 1.0: new_size = tuple([int(x * ratio) for x in old_size]) im = im.resize(new_size, Image.LANCZOS) # zero-pad the images new_size = im.size delta_w = target_size - new_size[0] delta_h = target_size - new_size[1] if delta_w < 0 or delta_h < 0: raise AttributeError( 'The target size is smaller than the image size {}.'.format( new_size)) elif delta_w > 0 or delta_h > 0: padding = (delta_w // 2, delta_h // 2, delta_w - (delta_w // 2), delta_h - (delta_h // 2)) im = ImageOps.expand(im, padding) # if image not RGB format, convert to RGB # This is done in case the image is greyscale if im.mode != 'RGB': im = im.convert('RGB') # convert the full image data to the jpeg compressed string to reduce tfrecord size with BytesIO() as fp: im.save(fp, format="JPEG") im_string = fp.getvalue() # save to tfrecords if image_index % num_images_per_tfrecord == 0: file_out = "{}_{:03d}.tfrecords".format( output_filename, image_index // num_images_per_tfrecord) # if file_out exist, raise an error, as that means this job has been done before if os.path.isfile(file_out): print('Job abortion: {} already exists.'.format(file_out)) break writer = tf.python_io.TFRecordWriter(file_out) if image_class is None: # for test set, the labels are unknown and not provided instance = tf.train.Example(features=tf.train.Features( feature={'x': _bytes_feature(im_string)})) else: instance = tf.train.Example(features=tf.train.Features( feature={ 'x': _bytes_feature(im_string), 'y': _int64_feature(im_cla) })) writer.write(instance.SerializeToString()) if image_index % 2000 == 0: sys.stdout.write('\r {}/{} instances finished.'.format( image_index + 1, num_images)) if image_index % num_images_per_tfrecord == (num_images_per_tfrecord - 1): writer.close() writer.close() duration = time.time() - start_time sys.stdout.write('\n All {} instances finished in {:.1f} seconds'.format( num_images, duration))
def data_achieve(hostid, host_user, database, host_passwd, pdf_set): ''' ''' const_width = 64 const_height = 64 redis_pool=redis.ConnectionPool(host='127.0.0.1', port=6379,db=0, password='******', encoding='utf-8') red = redis.Redis(connection_pool=redis_pool) elem_list = [] polygon_elem = {} with open("./data/elem_list.txt", "r") as f: for line in f: line = line.strip('\n') elem_info = json.loads(line) elem_id = elem_info["id"] elem_list.append(elem_id) connection = pymysql.connect(host=hostid, user=host_user, password=host_passwd, charset="utf8", use_unicode=True) db_cursor = connection.cursor() connection.select_db(database) for elem_id in elem_list: sql_polygon_id = 'select polygon_id from ocr_polygonelem where elem_id = (%s)' db_cursor.execute(sql_polygon_id, elem_id) polygon_id_set = db_cursor.fetchall() for polygon_id in polygon_id_set: polygonid = polygon_id[0] if polygonid in polygon_elem: polygon_elem[polygonid].append(elem_id) else: polygon_elem[polygonid] = [elem_id] data_label = [] elem_set = set() widgets = ['data_achieving: ', Percentage(), ' ', Bar('#'), ' ', Timer(), ' '] bar_achieve_label = progressbar.ProgressBar(widgets=widgets, maxval=len(polygon_elem)) bar_achieve_label.start() process_step = 0 for key in polygon_elem: # 获取polygon信息 sql_polygon = 'select labeling_content, pdfImage_id, polygon from ocr_ocrlabelingpolygon where id = %s' db_cursor.execute(sql_polygon, key) labeling_content, pdfImage_id, polygon = db_cursor.fetchone() sql_pdf = 'select ocrPDF_id from ocr_pdfimage where id = %s' db_cursor.execute(sql_pdf, pdfImage_id) pdf = db_cursor.fetchone()[0] in_PDF_set = pdf in pdf_set if in_PDF_set == False: continue if labeling_content == 0: process_step = process_step+1 continue points = json.loads(str(polygon, encoding = "utf8")) degree_to_rotate = cal_rotate_angle(points[0]['x'], points[0]['y'], points[3]['x'], points[3]['y']) degree_to_rotate = round(degree_to_rotate, 1) key_image_rotated = "%s_%s" % (pdfImage_id, degree_to_rotate) image_rotated = red.get(key_image_rotated) if image_rotated is None: # 获取原始图片image sql_pdfimage = 'select width, height, data_byte from ocr_pdfimage where id = %s' db_cursor.execute(sql_pdfimage, pdfImage_id) width, height, data_byte = db_cursor.fetchone() data_stream=io.BytesIO(data_byte) pil_image = Image.open(data_stream) gray = pil_image.convert('L') if abs(degree_to_rotate)<0.01: image_rotated = gray else: image_rotated = gray.rotate(degree_to_rotate) image_rotated = pickle.dumps(image_rotated) red.set(key_image_rotated, image_rotated) image_rotated = pickle.loads(image_rotated) pdf_width, pdf_height = image_rotated.size rotate_points(points, degree_to_rotate, pdf_width, pdf_height) bounding_points(points) rect_info = get_rect_info(points[0], points[2]) rect = (rect_info['x'], rect_info['y'], rect_info['x_'], rect_info['y_']) image_corp = image_rotated.crop(rect) width ,height = image_corp.size ratio_w =width*1.0/const_width ratio_h =height*1.0/const_height ratio = max(ratio_w, ratio_h) tar_width = min(int(width/ratio),const_width) tar_height = min(int(height/ratio),const_height) image_resized = image_corp.resize((tar_width, tar_height), Image.ANTIALIAS) tar_width, tar_height = image_resized.size w_extend = const_width - tar_width h_extend = const_height - tar_height w_l_extend = w_extend // 2 w_r_extend = w_extend -w_l_extend h_t_extend = h_extend // 2 h_b_extend = h_extend -h_t_extend image_padding = ImageOps.expand(image_resized, border=(w_l_extend, h_t_extend, w_r_extend, h_b_extend) ,fill=0) image_file = "./data/image/%s.png" % key image_padding.save(image_file) label= {'file': image_file, 'label': polygon_elem[key]} data_label.append(label) for elem in polygon_elem[key]: elem_set.add(elem) process_step = process_step+1 bar_achieve_label.update(process_step) bar_achieve_label.finish() elem_list = list(elem_set) elem_list.sort() with open('./data/elem_list.json', 'w') as f: json.dump(elem_list, f) with open('./data/label.json', 'w') as f: json.dump(data_label, f) db_cursor.close() connection.close()
def __call__(self, input): input['img'] = ImageOps.expand(input['img'], border=self.padding, fill=self.fill) return input
return images, labels #read train data(images and labels) trainImages, trainLabels = readTrafficSigns('GTSRB-2/Final_Training/Images') #Image padding for i, elem in enumerate(trainImages): h, w, d = elem.shape new_size = max(h, w) img = Image.fromarray(elem, 'RGB') delta_h = new_size - h delta_w = new_size - w padding = (delta_w // 2, delta_h // 2, delta_w - (delta_w // 2), delta_h - (delta_h // 2)) new_im = ImageOps.expand(img, padding) trainImages[i] = numpy.array(new_im) #Image resize for i, elem in enumerate(trainImages): size = image_size img = Image.fromarray(elem, 'RGB') trainImages[i] = numpy.array(ImageOps.fit(img, size, Image.ANTIALIAS)) # Split a dataset into a train and test set train_images = [] test_images = trainImages train_labels = [] test_labels = trainLabels train_size = 0.8 * len(trainImages)
i = 0 for i in range(len(a)): line() print('image %d size' % i) im = Image.open(a[i]) print(im.size) inimg = im.size if inimg[0] < inimg[1]: greater = inimg[1] else: greater = inimg[0] print(greater) img = Image.open(a[i]) img_with_border = ImageOps.expand(img, border=int(9 * greater / 40), fill='white') os.chdir(os.path.dirname(os.path.realpath(__file__))) os.chdir("result") print("dir changed to result") img_with_border.save('%d border.jpg' % i) print('%d border.jpg' % i + ' rough save done') line() print('%d border.jpg' % i + ' cropping') imc = Image.open('%d border.jpg' % i) print(imc.size) inimg = imc.size if inimg[0] < inimg[1]: print('This is vertical img')
else: print('%i NO possible candidate grid (%i:%i,%i:%i)' % (i, startgridx, startgridy, endgridx, endgridy)) else: matgrid[gridx[i], gridy[i]] = True gridcoord[i, 0] = gridx[i] gridcoord[i, 1] = gridy[i] valid[i] = True #print('%i free space'%i) # convert the grid coordinate to real img_res coordinates realcoordx = gridcoord[:, 0] * thumnail_res[0] realcoordy = gridcoord[:, 1] * thumnail_res[1] # create image buffer im = Image.new('RGB', img_res, 'white') # read the image provided in xy_id xy_path = [os.path.join(img_dir, x) for x in xy_id] # pasting image accordingly to buffer for i in range(n): im2 = Image.open(xy_path[i]) im2 = im2.resize(read_thumb_size) im2 = ImageOps.expand(im2, border=border_size, fill=0) im.paste(im2, (realcoordx[i], realcoordy[i])) # save the results im.save('%s_scatter.jpg' % current_time()) print 'done! Time elapsed: {} seconds'.format(time.time() - time_start)
def test(file_list, model_path): net = CrowdCounter() net.load_state_dict(torch.load(model_path)) # net = tr_net.CNN() # net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() maes = [] mses = [] for filename in file_list: print filename imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',',header=None).values den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') # prepare wd_1, ht_1 = img.size # pdb.set_trace() if wd_1 < cfg.DATA.STD_SIZE[1]: dif = cfg.DATA.STD_SIZE[1] - wd_1 img = ImageOps.expand(img, border=(0,0,dif,0), fill=0) pad = np.zeros([ht_1,dif]) den = np.array(den) den = np.hstack((den,pad)) if ht_1 < cfg.DATA.STD_SIZE[0]: dif = cfg.DATA.STD_SIZE[0] - ht_1 img = ImageOps.expand(img, border=(0,0,0,dif), fill=0) pad = np.zeros([dif,wd_1]) den = np.array(den) den = np.vstack((den,pad)) img = img_transform(img) gt = np.sum(den) img = Variable(img[None,:,:,:],volatile=True).cuda() #forward pred_map = net.test_forward(img) pred_map = pred_map.cpu().data.numpy()[0,0,:,:] pred = np.sum(pred_map)/100.0 maes.append(abs(pred-gt)) mses.append((pred-gt)*(pred-gt)) # vis pred_map = pred_map/np.max(pred_map+1e-20) pred_map = pred_map[0:ht_1,0:wd_1] den = den/np.max(den+1e-20) den = den[0:ht_1,0:wd_1] den_frame = plt.gca() plt.imshow(den, 'jet') den_frame.axes.get_yaxis().set_visible(False) den_frame.axes.get_xaxis().set_visible(False) den_frame.spines['top'].set_visible(False) den_frame.spines['bottom'].set_visible(False) den_frame.spines['left'].set_visible(False) den_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.mat',{'data':den}) pred_frame = plt.gca() plt.imshow(pred_map, 'jet') pred_frame.axes.get_yaxis().set_visible(False) pred_frame.axes.get_xaxis().set_visible(False) pred_frame.spines['top'].set_visible(False) pred_frame.spines['bottom'].set_visible(False) pred_frame.spines['left'].set_visible(False) pred_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.mat',{'data':pred_map}) diff = den-pred_map diff_frame = plt.gca() plt.imshow(diff, 'jet') plt.colorbar() diff_frame.axes.get_yaxis().set_visible(False) diff_frame.axes.get_xaxis().set_visible(False) diff_frame.spines['top'].set_visible(False) diff_frame.spines['bottom'].set_visible(False) diff_frame.spines['left'].set_visible(False) diff_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_diff.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_diff.mat',{'data':diff}) print '[file %s]: [pred %.2f], [gt %.2f]' % (filename, pred, gt) print np.average(np.array(maes)) print np.sqrt(np.average(np.array(mses)))
def pad(img, padding, fill=0, padding_mode='constant'): r"""Pad the given PIL Image on all sides with specified padding mode and fill value. Args: img (PIL Image): Image to be padded. padding (int or tuple): Padding on each border. If a single int is provided this is used to pad all borders. If tuple of length 2 is provided this is the padding on left/right and top/bottom respectively. If a tuple of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. fill: Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. - constant: pads with a constant value, this value is specified with fill - edge: pads with the last value on the edge of the image - reflect: pads with reflection of image (without repeating the last value on the edge) padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2] - symmetric: pads with reflection of image (repeating the last value on the edge) padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3] Returns: PIL Image: Padded image. """ if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) if not isinstance(padding, (numbers.Number, tuple)): raise TypeError('Got inappropriate padding arg') if not isinstance(fill, (numbers.Number, str, tuple)): raise TypeError('Got inappropriate fill arg') if not isinstance(padding_mode, str): raise TypeError('Got inappropriate padding_mode arg') if isinstance(padding, Sequence) and len(padding) not in [2, 4]: raise ValueError( "Padding must be an int or a 2, or 4 element tuple, not a " + "{} element tuple".format(len(padding))) assert padding_mode in ['constant', 'edge', 'reflect', 'symmetric'], \ 'Padding mode should be either constant, edge, reflect or symmetric' if padding_mode == 'constant': return ImageOps.expand(img, border=padding, fill=fill) else: if isinstance(padding, int): pad_left = pad_right = pad_top = pad_bottom = padding if isinstance(padding, Sequence) and len(padding) == 2: pad_left = pad_right = padding[0] pad_top = pad_bottom = padding[1] if isinstance(padding, Sequence) and len(padding) == 4: pad_left = padding[0] pad_top = padding[1] pad_right = padding[2] pad_bottom = padding[3] img = np.asarray(img) # RGB image if len(img.shape) == 3: img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)), padding_mode) # Grayscale image if len(img.shape) == 2: img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode) return Image.fromarray(img)
from PIL import Image, ImageOps img = Image.open('beijo_menor.jpg') new_img = ImageOps.expand(img, border=30, fill='white') new_img.show()
def apply_effect(layer, backdrop, base_image): """Apply effect to the image. ..note: Correct effect order is the following. All the effects are first applied to the original image then blended together. * dropshadow * outerglow * (original) * patternoverlay * gradientoverlay * coloroverlay * innershadow * innerglow * bevelemboss * satin * stroke """ from PIL import ImageChops for effect in layer.effects: if effect.__class__.__name__ == 'PatternOverlay': image = draw_pattern_fill(base_image.size, layer._psd, effect.value) if base_image.mode.endswith('A'): alpha = base_image.getchannel('A') if image.mode.endswith('A'): alpha = ImageChops.darker(alpha, image.getchannel('A')) image.putalpha(alpha) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) for effect in layer.effects: if effect.__class__.__name__ == 'GradientOverlay': image = draw_gradient_fill(base_image.size, effect.value) if base_image.mode.endswith('A'): alpha = base_image.getchannel('A') if image.mode.endswith('A'): alpha = ImageChops.darker(alpha, image.getchannel('A')) image.putalpha(alpha) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) for effect in layer.effects: if effect.__class__.__name__ == 'ColorOverlay': image = draw_solid_color_fill(base_image.size, effect.value) if base_image.mode.endswith('A'): alpha = base_image.getchannel('A') if image.mode.endswith('A'): alpha = ImageChops.darker(alpha, image.getchannel('A')) image.putalpha(alpha) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) for effect in layer.effects: if effect.__class__.__name__ == 'Stroke': from PIL import ImageOps if layer.has_vector_mask(): alpha = draw_vector_mask(layer) elif base_image.mode.endswith('A'): alpha = base_image.getchannel('A') else: alpha = base_image.convert('L') alpha.info['offset'] = base_image.info['offset'] flat = alpha.getextrema()[0] < 255 # Expand the image size setting = effect.value size = int(setting.get(Key.SizeKey)) offset = backdrop.info['offset'] backdrop = ImageOps.expand(backdrop, size) backdrop.info['offset'] = tuple(x - size for x in offset) offset = alpha.info['offset'] alpha = ImageOps.expand(alpha, size) alpha.info['offset'] = tuple(x - size for x in offset) if not layer.has_vector_mask() and setting.get( Key.Style).enum == Enum.InsetFrame and flat: image = create_stroke_effect(alpha, setting, layer._psd, True) backdrop.paste(image) else: image = create_stroke_effect(alpha, setting, layer._psd) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) return backdrop
def _train_sync_transform(self, img, mask): ''' :param image: PIL input image :param gt_image: PIL input gt_image :return: ''' if self.random_mirror: # random mirror if random.random() < 0.5: img = img.transpose(Image.FLIP_LEFT_RIGHT) if mask: mask = mask.transpose(Image.FLIP_LEFT_RIGHT) crop_w, crop_h = self.crop_size if self.random_crop: # random scale base_w, base_h = self.base_size w, h = img.size assert w >= h if (base_w / w) > (base_h / h): base_size = base_w short_size = random.randint(int(base_size * 0.5), int(base_size * 2.0)) ow = short_size oh = int(1.0 * h * ow / w) else: base_size = base_h short_size = random.randint(int(base_size * 0.5), int(base_size * 2.0)) oh = short_size ow = int(1.0 * w * oh / h) img = img.resize((ow, oh), Image.BICUBIC) if mask: mask = mask.resize((ow, oh), Image.NEAREST) # pad crop if ow < crop_w or oh < crop_h: padh = crop_h - oh if oh < crop_h else 0 padw = crop_w - ow if ow < crop_w else 0 img = ImageOps.expand(img, border=(0, 0, padw, padh), fill=0) if mask: mask = ImageOps.expand(mask, border=(0, 0, padw, padh), fill=0) # random crop crop_size w, h = img.size x1 = random.randint(0, w - crop_w) y1 = random.randint(0, h - crop_h) img = img.crop((x1, y1, x1 + crop_w, y1 + crop_h)) if mask: mask = mask.crop((x1, y1, x1 + crop_w, y1 + crop_h)) elif self.resize: img = img.resize(self.crop_size, Image.BICUBIC) if mask: mask = mask.resize(self.crop_size, Image.NEAREST) if self.gaussian_blur: # gaussian blur as in PSP if random.random() < 0.5: img = img.filter( ImageFilter.GaussianBlur(radius=random.random())) # final transform if mask: img, mask = self._img_transform(img), self._mask_transform(mask) return img, mask else: img = self._img_transform(img) return img
def add_border(self, image): return ImageOps.expand(image, border=41, fill='black')
def resizeImage(self, qualityMode=None): upscale = self.opt.upscale stretch = self.opt.stretch bordersColor = self.opt.bordersColor if qualityMode is None: qualityMode = self.opt.quality if bordersColor: fill = bordersColor else: fill = self.fill # Set target size if qualityMode == 0: size = (self.size[0], self.size[1]) elif qualityMode == 1 and not stretch and not upscale and self.image.size[0] <=\ self.size[0] and self.image.size[1] <= self.size[1]: size = (self.size[0], self.size[1]) elif qualityMode == 1: # Forcing upscale to make sure that margins will be not too big if not stretch: upscale = True size = (self.panelviewsize[0], self.panelviewsize[1]) elif qualityMode == 2 and not stretch and not upscale and self.image.size[0] <=\ self.size[0] and self.image.size[1] <= self.size[1]: self.purge = True return self.image else: self.hq = True size = (self.panelviewsize[0], self.panelviewsize[1]) # If stretching is on - Resize without other considerations if stretch: if self.image.size[0] <= size[0] and self.image.size[1] <= size[1]: method = Image.BICUBIC else: method = Image.LANCZOS self.image = self.image.resize(size, method) return self.image # If image is smaller than target resolution and upscale is off - Just expand it by adding margins if self.image.size[0] <= size[0] and self.image.size[1] <= size[ 1] and not upscale: borderw = int((size[0] - self.image.size[0]) / 2) borderh = int((size[1] - self.image.size[1]) / 2) # PV is disabled when source image is smaller than device screen and upscale is off if self.image.size[0] <= self.size[0] and self.image.size[ 1] <= self.size[1]: self.noPV = True self.image = ImageOps.expand(self.image, border=(borderw, borderh), fill=fill) # Border can't be float so sometimes image might be 1px too small/large if self.image.size[0] != size[0] or self.image.size[1] != size[1]: self.image = ImageOps.fit(self.image, size, method=Image.BICUBIC, centering=(0.5, 0.5)) return self.image # Otherwise - Upscale/Downscale ratioDev = float(size[0]) / float(size[1]) if (float(self.image.size[0]) / float(self.image.size[1])) < ratioDev: diff = int(self.image.size[1] * ratioDev) - self.image.size[0] self.image = ImageOps.expand(self.image, border=(int(diff / 2), 0), fill=fill) elif (float(self.image.size[0]) / float(self.image.size[1])) > ratioDev: diff = int(self.image.size[0] / ratioDev) - self.image.size[1] self.image = ImageOps.expand(self.image, border=(0, int(diff / 2)), fill=fill) if self.image.size[0] <= size[0] and self.image.size[1] <= size[1]: method = Image.BICUBIC else: method = Image.LANCZOS self.image = ImageOps.fit(self.image, size, method=method, centering=(0.5, 0.5)) return self.image
def add_border(x, color='', size=2): from PIL import ImageOps if color is not '': x = ImageOps.expand(x, border=size, fill=color) return x
os.rename(filename, (str(int(filename[4:5]) + MATSIZE * j) + '.png')) elif filename.startswith("0" + str(j + 1) + "_") and j + 1 > 10: os.rename(filename, (str(int(filename[4:6]) + MATSIZE * j) + '.png')) x = (300 / (2 * MATSIZE)) x = x - 1 for i in range(d): imgx = Image.open(str(i + 1) + '.png') halfwidth = imgx.size[0] / 2 halfheight = imgx.size[1] / 2 imgcrop = imgx.crop( (halfwidth - x, halfheight - x, halfwidth + x, halfheight + x)) imgcrop.save(str(i + 1) + '.png') imgx = Image.open(str(i + 1) + '.png') imgborder = ImageOps.expand(imgx, border=5, fill='white') imgborder.save(str(i + 1) + '.png') pygame.init() INDS = 300 / MATSIZE MP = 1 RANDOMIZEUPTO = 1 FPS = 30 # frames per second setting fpsClock = pygame.time.Clock() NumberOfMoves = 0 BLACK = (0, 0, 0) # set up the window DISPLAYSURF = pygame.display.set_mode((400, 400), 0, 32) pygame.display.set_caption('Tile Game')
from PIL import Image, ImageOps from sys import argv try: image = argv[2] number = int(argv[1]) output = argv[3] im = Image.open(image) (width, height) = im.size if (width + number) > 11000: print('Too many pixels') raise SystemExit() if (height + number) > 11000: print('Too many pixels') raise SystemExit() if number < 0: print('Bad pixel number') raise SystemExit() ImageOps.expand(im, border=number, fill='black').save(output) except IndexError: print('No arguments') except FileNotFoundError: print('File not found') except MemoryError: print('Not enough memory')
def pad( img: Image.Image, padding: Union[int, List[int], Tuple[int, ...]], fill: Optional[Union[float, List[float], Tuple[float, ...]]] = 0, padding_mode: Literal["constant", "edge", "reflect", "symmetric"] = "constant", ) -> Image.Image: if not _is_pil_image(img): raise TypeError(f"img should be PIL Image. Got {type(img)}") if not isinstance(padding, (numbers.Number, tuple, list)): raise TypeError("Got inappropriate padding arg") if not isinstance(fill, (numbers.Number, str, tuple)): raise TypeError("Got inappropriate fill arg") if not isinstance(padding_mode, str): raise TypeError("Got inappropriate padding_mode arg") if isinstance(padding, list): padding = tuple(padding) if isinstance(padding, tuple) and len(padding) not in [1, 2, 4]: raise ValueError(f"Padding must be an int or a 1, 2, or 4 element tuple, not a {len(padding)} element tuple") if isinstance(padding, tuple) and len(padding) == 1: # Compatibility with `functional_tensor.pad` padding = padding[0] if padding_mode not in ["constant", "edge", "reflect", "symmetric"]: raise ValueError("Padding mode should be either constant, edge, reflect or symmetric") if padding_mode == "constant": opts = _parse_fill(fill, img, name="fill") if img.mode == "P": palette = img.getpalette() image = ImageOps.expand(img, border=padding, **opts) image.putpalette(palette) return image return ImageOps.expand(img, border=padding, **opts) else: if isinstance(padding, int): pad_left = pad_right = pad_top = pad_bottom = padding if isinstance(padding, tuple) and len(padding) == 2: pad_left = pad_right = padding[0] pad_top = pad_bottom = padding[1] if isinstance(padding, tuple) and len(padding) == 4: pad_left = padding[0] pad_top = padding[1] pad_right = padding[2] pad_bottom = padding[3] p = [pad_left, pad_top, pad_right, pad_bottom] cropping = -np.minimum(p, 0) if cropping.any(): crop_left, crop_top, crop_right, crop_bottom = cropping img = img.crop((crop_left, crop_top, img.width - crop_right, img.height - crop_bottom)) pad_left, pad_top, pad_right, pad_bottom = np.maximum(p, 0) if img.mode == "P": palette = img.getpalette() img = np.asarray(img) img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), mode=padding_mode) img = Image.fromarray(img) img.putpalette(palette) return img img = np.asarray(img) # RGB image if len(img.shape) == 3: img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)), padding_mode) # Grayscale image if len(img.shape) == 2: img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode) return Image.fromarray(img)
def expand(v=30): v = int(v) image = Image.open(name) image = ImageOps.expand(image, border=v) image.save(name)
def writeBezelConfig(bezel, retroarchConfig, systemName, rom, gameResolution, bezel_stretch): # disable the overlay # if all steps are passed, enable them retroarchConfig['input_overlay_hide_in_menu'] = "false" overlay_cfg_file = batoceraFiles.overlayConfigFile # bezel are disabled # default values in case something wrong append retroarchConfig['input_overlay_enable'] = "false" retroarchConfig['video_message_pos_x'] = 0.05 retroarchConfig['video_message_pos_y'] = 0.05 if bezel is None: return bz_infos = bezelsUtil.getBezelInfos(rom, bezel, systemName) if bz_infos is None: return overlay_info_file = bz_infos["info"] overlay_png_file = bz_infos["png"] bezel_game = bz_infos["specific_to_game"] # only the png file is mandatory if os.path.exists(overlay_info_file): try: infos = json.load(open(overlay_info_file)) except: infos = {} else: infos = {} # if image is not at the correct size, find the correct size bezelNeedAdaptation = False viewPortUsed = True if "width" not in infos or "height" not in infos or "top" not in infos or "left" not in infos or "bottom" not in infos or "right" not in infos: viewPortUsed = False gameRatio = float(gameResolution["width"]) / float( gameResolution["height"]) if viewPortUsed: if gameResolution["width"] != infos["width"] or gameResolution[ "height"] != infos["height"]: if gameRatio < 1.6: # let's use bezels only for 16:10, 5:3, 16:9 and wider aspect ratios return else: bezelNeedAdaptation = True retroarchConfig['aspect_ratio_index'] = str( ratioIndexes.index( "custom")) # overwritten from the beginning of this file else: # when there is no information about width and height in the .info, assume that the tv is HD 16/9 and infos are core provided if gameRatio < 1.6: # let's use bezels only for 16:10, 5:3, 16:9 and wider aspect ratios return else: # No info on the bezel, let's get the bezel image width and height and apply the # ratios from usual 16:9 1920x1080 bezels (example: theBezelProject) try: infos["width"], infos["height"] = bezelsUtil.fast_image_size( overlay_png_file) infos["top"] = int(infos["height"] * 2 / 1080) infos["left"] = int( infos["width"] * 241 / 1920 ) # 241 = (1920 - (1920 / (4:3))) / 2 + 1 pixel = where viewport start infos["bottom"] = int(infos["height"] * 2 / 1080) infos["right"] = int(infos["width"] * 241 / 1920) bezelNeedAdaptation = True except: pass # outch, no ratio will be applied. if gameResolution["width"] == infos["width"] and gameResolution[ "height"] == infos["height"]: bezelNeedAdaptation = False retroarchConfig['aspect_ratio_index'] = str(ratioIndexes.index("core")) retroarchConfig['input_overlay_enable'] = "true" retroarchConfig['input_overlay_scale'] = "1.0" retroarchConfig['input_overlay'] = overlay_cfg_file retroarchConfig['input_overlay_hide_in_menu'] = "true" if "opacity" not in infos: infos["opacity"] = 1.0 if "messagex" not in infos: infos["messagex"] = 0.0 if "messagey" not in infos: infos["messagey"] = 0.0 retroarchConfig['input_overlay_opacity'] = infos["opacity"] if bezelNeedAdaptation: wratio = gameResolution["width"] / float(infos["width"]) hratio = gameResolution["height"] / float(infos["height"]) # If width or height < original, can't add black borders, need to stretch if gameResolution["width"] < infos["width"] or gameResolution[ "height"] < infos["height"]: bezel_stretch = True if bezel_stretch: retroarchConfig['custom_viewport_x'] = infos["left"] * wratio retroarchConfig['custom_viewport_y'] = infos["top"] * hratio retroarchConfig['custom_viewport_width'] = ( infos["width"] - infos["left"] - infos["right"]) * wratio retroarchConfig['custom_viewport_height'] = ( infos["height"] - infos["top"] - infos["bottom"]) * hratio retroarchConfig['video_message_pos_x'] = infos["messagex"] * wratio retroarchConfig['video_message_pos_y'] = infos["messagey"] * hratio else: if bezel_game is True: output_png_file = "/tmp/bezel_game_adapted.png" create_new_bezel_file = True else: create_new_bezel_file = False output_png_file = "/tmp/" + os.path.splitext( os.path.basename(overlay_png_file))[0] + "_adapted.png" if os.path.exists(output_png_file) is False: create_new_bezel_file = True else: if os.path.getmtime(output_png_file) < os.path.getmtime( overlay_png_file): create_new_bezel_file = True # fast way of checking the size of a png oldwidth, oldheight = bezelsUtil.fast_image_size(output_png_file) if (oldwidth != gameResolution["width"] or oldheight != gameResolution["height"]): create_new_bezel_file = True xoffset = gameResolution["width"] - infos["width"] yoffset = gameResolution["height"] - infos["height"] retroarchConfig['custom_viewport_x'] = infos["left"] + xoffset / 2 retroarchConfig['custom_viewport_y'] = infos["top"] + yoffset / 2 retroarchConfig['custom_viewport_width'] = infos["width"] - infos[ "left"] - infos["right"] retroarchConfig['custom_viewport_height'] = infos[ "height"] - infos["top"] - infos["bottom"] retroarchConfig[ 'video_message_pos_x'] = infos["messagex"] + xoffset / 2 retroarchConfig[ 'video_message_pos_y'] = infos["messagey"] + yoffset / 2 if create_new_bezel_file is True: # Padding left and right borders for ultrawide screens (larger than 16:9 aspect ratio) # or up/down for 4K eslog.log("Generating a new adapted bezel file {}".format( output_png_file)) fillcolor = 'black' borderw = 0 borderh = 0 if wratio > 1: borderw = xoffset / 2 if hratio > 1: borderh = yoffset / 2 imgin = Image.open(overlay_png_file) if imgin.mode != "RGBA": # TheBezelProject have Palette + alpha, not RGBA. PIL can't convert from P+A to RGBA. # Even if it can load P+A, it can't save P+A as PNG. So we have to recreate a new image to adapt it. if not 'transparency' in imgin.info: return # no transparent layer for the viewport, abort alpha = imgin.split()[ -1] # alpha from original palette + alpha ix, iy = imgin.size imgnew = Image.new("RGBA", (ix, iy), (0, 0, 0, 255)) imgnew.paste(alpha, (0, 0, ix, iy)) imgout = ImageOps.expand(imgnew, border=(borderw, borderh, xoffset - borderw, yoffset - borderh), fill=fillcolor) imgout.save(output_png_file, mode="RGBA", format="PNG") else: imgout = ImageOps.expand(imgin, border=(borderw, borderh, xoffset - borderw, yoffset - borderh), fill=fillcolor) imgout.save(output_png_file, mode="RGBA", format="PNG") overlay_png_file = output_png_file # replace by the new file (recreated or cached in /tmp) else: if viewPortUsed: retroarchConfig['custom_viewport_x'] = infos["left"] retroarchConfig['custom_viewport_y'] = infos["top"] retroarchConfig['custom_viewport_width'] = infos["width"] - infos[ "left"] - infos["right"] retroarchConfig['custom_viewport_height'] = infos[ "height"] - infos["top"] - infos["bottom"] retroarchConfig['video_message_pos_x'] = infos["messagex"] retroarchConfig['video_message_pos_y'] = infos["messagey"] eslog.log("Bezel file set to {}".format(overlay_png_file)) writeBezelCfgConfig(overlay_cfg_file, overlay_png_file)
if student.AdjectivesIGet.exists(): createWordCloud(student) ########################################## # prepare directory ROOT_DIR = "media/collage_and_yearbook_personal" student_dir_path = os.path.join(ROOT_DIR, student.user.username) folder_path = os.path.join(student_dir_path, 'collages') if os.path.exists(folder_path) and os.path.isdir(folder_path): shutil.rmtree(folder_path) os.makedirs(folder_path) if student.closeFriendsPic: rgb_img = Image.open(student.closeFriendsPic.path).convert('RGB') ImageOps.expand(rgb_img, border=200, fill='white').save( os.path.join(student_dir_path, "closeFriendsPic.jpg")) for friendUserName in friendsGroup: i = User.objects.get(username=(friendUserName).lower()).student if i.closeFriendsPic: shutil.copyfile( i.closeFriendsPic.path, os.path.join(folder_path, os.path.basename(i.closeFriendsPic.name))) ########################################## # generate collage ROOT_DIR = "media/collage_and_yearbook_personal" BATCH_SIZE = 8
def start(): startbutton.config(state='disabled') browsebutton.config(state='disabled') mvar = 'Creating wallpaper. Please wait...' messvar.set(mvar) ### CODE ### print('>> Opening image...') img = i.open(filename) wid, hei = math.ceil( img.size[1] * (16 / 9)), img.size[1] # Working out 16:9 width for original height # print(f'>> Orig size: {img.size}') # print(f'>> New size: {wid, hei}') mode = 'RGBA' global bkg bkg = i.new(mode, (wid, hei)) # Background def split( pos ): # Splits image in 2 and puts top half on the left and bottom on the right imgcent = math.ceil(hei / 2) # Image center blur = hei / 200 global fopt if pos == 't': print('>> Creating left background...') s = img.crop(box=( 0, 0, img.size[0], imgcent)) # Cropping image - 4 tuple: left,top,right,bottom elif pos == 'b': print('>> Creating right background...') s = img.crop(box=(0, imgcent, img.size[0], img.size[1])) sr = s.resize(tuple( z * 2 for z in s.size)) # Scaling up by 2 because img was split in two if cmvar.get() == 1: # Colour map if invvar.get() == 1: cmblack = cmwvar.get() cmwhite = cmbvar.get() else: cmblack = cmbvar.get() cmwhite = cmwvar.get() sr = sr.convert('L') # Convert to greyscale sr = ImageOps.colorize(sr, black=cmblack, white=cmwhite) # colour map if fopt.get() == 0: # Filter options pass else: if fopt.get() != 2: # If radio button 3 not chosen sr = sr.filter( ImageFilter.GaussianBlur(radius=blur)) # Gaussian blur if fopt.get() != 1: # If radio button 2 not chosen # https://stackoverflow.com/questions/43618910/pil-drawing-a-semi-transparent-square-overlay-on-image sr = i.eval(sr, lambda x: x / 2) if plbvar.get() == 0: # Matplotlib colour map pass else: pltcm = matplotlib.cm.get_cmap(pltvar.get()) # color map sr = sr.convert('L') sr = np.array(sr) sr = pltcm(sr) sr = np.uint8(sr * 255) sr = i.fromarray(sr) if icvar.get() == 1: # Invert colours sr = ImageOps.invert(sr) return sr ## Working out where top and bottom splits are to be pasted print('>> Calculating dimensions...') sw = math.ceil((wid - img.size[0]) / 2) # split width tspos = (math.ceil((sw / 2) - img.size[0]), 0) # Top split position bspos = (math.ceil((wid - sw / 2) - img.size[0]), 0 ) # Bottom split position print('>> Creating background...') bkg.paste(split('t'), box=tspos) bkg.paste(split('b'), box=bspos) bkg.paste(img, box=(math.ceil((wid / 2) - (img.size[0] / 2)), 0)) # Paste original image in the center of new image # Add border if bordvar.get() == 1: bkg = ImageOps.expand(bkg, border=wid // 100, fill='black') elif bordvar.get() == 0: pass print('>> Exporting image...') dt = time.strftime('%Y-%m-%d_%H-%M-%S') path = f'./walls/wallpaper-{dt}.png' previmg = ImageTk.PhotoImage( image=bkg) # Creating a PhotoImage of image object to load on canvas setprev = preview.create_image( 0, 0, image=previmg) # Loading photoimage on canvas preview.itemconfig(setprev) tkinter.Tk() # bkg.save(path) # bkg.show() # ~ Resetting GUI ~ startbutton.config(state='normal') browsebutton.config(state='normal') bordbutton.config(state='normal') mvar = f'Done. File saved as ./walls/{dt}.png\n' print(f'>> {mvar}') messvar.set(mvar)
for i, j in zip(activationLabel, map(str, chartLegendPercent)): legendLabels.append(i + ' (' + j + ' %)') colors = plt.rcParams['axes.prop_cycle'].by_key()['color'] fig1 = plt.figure() plt.pie(activationValue, labels=None, colors=colors, explode=explodeValues, autopct=None, shadow=False, startangle=90) plt.axis('equal') plt.title('User status', pad=20, fontsize=15) plt.legend(legendLabels, loc='best', fontsize=10) fig1.savefig(workDirectory+'myplot1.png', dpi=70) plt.clf() im = Image.open(workDirectory+'myplot1.png') bordered = ImageOps.expand(im, border=1, fill=(0, 0, 0)) bordered.save(workDirectory+'myplot1.png') # INSERT CHART IN EXCEL img = openpyxl.drawing.image.Image(workDirectory+'myplot1.png') img.anchor = 'A8' workbook['Registrations'].add_image(img) workbook.save(outputExcelFile) # CHART CATEGORIES chartLabel = df_Categories_count['Categories'].tolist() chartLegendLabel = df_Categories_count['Categories'].tolist() chartValue = df_Categories_count['Total'].tolist() chartLegendPercent = df_Categories_count['Percent'].tolist()
def start(): startbutton.config(state='disabled') previewbutton.config(state='disabled') browsebutton.config(state='disabled') mvar = 'Creating wallpaper. Please wait...' messvar.set(mvar) ### CODE ### print('>> Opening image...') img = i.open(filename) origimg = img # Original image to be used later wid, hei = math.ceil( img.size[1] * (16 / 9)), img.size[1] # Working out 16:9 width for original height # print(f'>> Orig size: {img.size}') # print(f'>> New size: {wid, hei}') mode = 'RGBA' global bkg bkg = i.new(mode, (wid, hei)) # Background if cmvar.get() == 1: # Colour map if invvar.get() == 1: cmblack = cmwvar.get() cmwhite = cmbvar.get() else: cmblack = cmbvar.get() cmwhite = cmwvar.get() img = img.convert('L') # Convert to greyscale img = ImageOps.colorize(img, black=cmblack, white=cmwhite) # colour map ## Matplotlib colour map if plbvar.get() == 0: pass else: print(f'>> Applying {pltvar.get()} colour map...') pltcm = matplotlib.cm.get_cmap(pltvar.get()) # color map img = img.convert('L') img = np.array(img) img = pltcm(img) img = np.uint8(img * 255) img = i.fromarray(img) ## Invert colours if icvar.get() == 1: print('>> Inverting image...') img = img.convert('RGB') # print(img.mode) img = ImageOps.invert(img) ## Gaussian Blur blurval = int(blurslider.get()) # Slider value if blurval == 0: # Filter options pass else: print('>> Applying Gaussian Blur...') # blur = hei/()*8 img = img.filter( ImageFilter.GaussianBlur(radius=(blurval * 0.1))) # Gaussian blur ## Darken if fopt.get() == 2 or fopt.get() == 3: # If radio button 2 not chosen # https://stackoverflow.com/questions/43618910/pil-drawing-a-semi-transparent-square-overlay-on-image ndimg = img # Non darkened image to paste on top img = i.eval(img, lambda x: x / 1.5) ## Split image def split( pos ): # Splits image in 2 and puts top half on the left and bottom on the right imgcent = math.ceil(hei / 2) # Image center global fopt if pos == 't': print('>> Creating left background...') s = img.crop(box=( 0, 0, img.size[0], imgcent)) # Cropping image - 4 tuple: left,top,right,bottom elif pos == 'b': print('>> Creating right background...') s = img.crop(box=(0, imgcent, img.size[0], img.size[1])) sr = s.resize(tuple( z * 2 for z in s.size)) # Scaling up by 2 because img was split in two return sr ## Working out where top and bottom splits are to be pasted print('>> Calculating dimensions...') sw = math.ceil((wid - img.size[0]) / 2) # split width tspos = (math.ceil((sw / 2) - img.size[0]), 0) # Top split position bspos = (math.ceil((wid - sw / 2) - img.size[0]), 0 ) # Bottom split position print('>> Creating background...') bkg.paste(split('t'), box=tspos) bkg.paste(split('b'), box=bspos) if fopt.get() == 1 or fopt.get() == 3: # If radiobutton 2 or 4 are chosen bkg.paste(ndimg, box=(math.ceil((wid / 2) - (img.size[0] / 2)), 0)) # Paste edited image in the center of new image else: bkg.paste(origimg, box=(math.ceil((wid / 2) - (img.size[0] / 2)), 0)) # Paste original image in the center of new image # Add border if bordvar.get() == 1: bkg = ImageOps.expand(bkg, border=wid // 100, fill='black') elif bordvar.get() == 0: pass prevbkg = bkg.resize((800, 450)) # Resizing preview image to fit on canvas previmg = ImageTk.PhotoImage( image=prevbkg ) # Creating a PhotoImage of image object to load on canvas preview.create_image(0, 0, image=previmg, anchor='nw') # Loading photoimage on canvas preview.image = previmg # https://web.archive.org/web/20201111190625id_/http://effbot.org/pyfaq/why-do-my-tkinter-images-not-appear.htm # preview.itemconfig(setprev) # tkinter.Tk() # master.mainloop() # ~ Resetting GUI ~ startbutton.config(state='normal') previewbutton.config(state='normal') browsebutton.config(state='normal') bordbutton.config(state='normal')