def hflip(img, lab): # Flip image and label if necessary. # 3 classes if self.is_hflip3: if np.random.binomial(1, 0.5) != 1: return img, lab # Flip left and right labels. if lab == 0: lab = 2 elif lab == 2: lab = 0 # Do horizontal flip of the image. img = ImageOps.mirror(img) elif self.is_hflip5: if np.random.binomial(1, 0.5) != 1: return img, lab # Flip L_c and R_c or C_l and C_r label_remap = {0:4, 1:3, 2:2, 3:1, 4:0} lab = label_remap[lab] # Do horizontal flip of the image. img = ImageOps.mirror(img) elif self.is_hflip: # Just flip the image. if np.random.binomial(1, 0.5) == 1: img = ImageOps.mirror(img) return img, lab
def compare(ab, ac, image_b, image_c, problem, options): if max(ac, ab) < .5: # no answer return max(ac, ab), (max(ac, ab), -1) if ab >= ac: return max(ac, ab), (searchForSolution(problem, ImageOps.mirror(image_c), options)) return max(ac, ab), (searchForSolution(problem, ImageOps.mirror(image_b), options))
def make_mirror(self, image): if image == 1: self.img1.image = ImageOps.mirror(self.img1.image) elif image == 2: self.img2.image = ImageOps.mirror(self.img2.image) elif image == 3: self.img3.image = ImageOps.mirror(self.img3.image)
def invertingAndCompare(problem, figures, options): av_invert = ImageOps.flip(um.openAndInvert(figures[0])) bv_invert = ImageOps.flip(um.openAndInvert(figures[1])) ah_invert = ImageOps.mirror(um.openAndInvert(figures[0])) dh_invert = ImageOps.mirror(um.openAndInvert(figures[3])) aTog = um.measurePixelDifference(av_invert, um.openAndInvert(figures[6])) bToh = um.measurePixelDifference(bv_invert, um.openAndInvert(figures[7])) aToc = um.measurePixelDifference(ah_invert, um.openAndInvert(figures[2])) dTof = um.measurePixelDifference(dh_invert, um.openAndInvert(figures[5])) direction = um.determineDirection(aToc, dTof, aTog, bToh, figures) return direction[1], um.searchForSolution(problem, direction[0], options)
def espejo(): global imSerializable label.destroy() grande=Image.open("grande.jpeg") grande=grande.resize((640,353)) largo, ancho =imSerializable.size if largo<800 or ancho <800: imSerializable= ImageOps.mirror(imSerializable) refresca(imSerializable) else: imSerializable= ImageOps.mirror(imSerializable) refresca(grande) tkMessageBox.showinfo("¡ Mensaje !","Imagen Editada Correctamente\n\n * Puede Seguir Editando\n\n *Para ver los resultados vaya a su carpeta contendora")
def checkWhileMirrored(problem, figure_a, figure_b, figure_c, options): image_a = um.openAndInvert(figure_a) image_b = um.openAndInvert(figure_b) image_c = um.openAndInvert(figure_c) # check based on reflection using ImageOps # http://pillow.readthedocs.io/en/3.1.x/reference/ImageOps.html # http://stackoverflow.com/questions/14182642/fliping-image-mirror-image # http://effbot.org/imagingbook/imageops.htm#tag-ImageOps.mirror # first get the pixel difference then do a -> b and a -> comparison ab = um.measurePixelDifference(ImageOps.mirror(image_a), image_b) ac = um.measurePixelDifference(ImageOps.mirror(image_a), image_c) # get optimal max return um.compare(ab, ac, image_b, image_c, problem, options)
def checkWhileMirrored(problem, figure_a, figure_b, figure_c, options): image_a = Image.open(figure_a.visualFilename).convert('L') image_b = Image.open(figure_b.visualFilename).convert('L') image_c = Image.open(figure_c.visualFilename).convert('L') # check based on reflection using ImageOps # http://pillow.readthedocs.io/en/3.1.x/reference/ImageOps.html # http://stackoverflow.com/questions/14182642/fliping-image-mirror-image # http://effbot.org/imagingbook/imageops.htm#tag-ImageOps.mirror # first get the pixel difference then do a -> b and a -> comparison ab = Util.getPixelRatio(ImageOps.mirror(image_a), image_b) ac = Util.getPixelRatio(ImageOps.mirror(image_a), image_c) # get optimal max return Util.compare(ab, ac, image_b, image_c, problem, options)
def test_sanity(): ImageOps.autocontrast(lena("L")) ImageOps.autocontrast(lena("RGB")) ImageOps.autocontrast(lena("L"), cutoff=10) ImageOps.autocontrast(lena("L"), ignore=[0, 255]) ImageOps.colorize(lena("L"), (0, 0, 0), (255, 255, 255)) ImageOps.colorize(lena("L"), "black", "white") ImageOps.crop(lena("L"), 1) ImageOps.crop(lena("RGB"), 1) ImageOps.deform(lena("L"), deformer) ImageOps.deform(lena("RGB"), deformer) ImageOps.equalize(lena("L")) ImageOps.equalize(lena("RGB")) ImageOps.expand(lena("L"), 1) ImageOps.expand(lena("RGB"), 1) ImageOps.expand(lena("L"), 2, "blue") ImageOps.expand(lena("RGB"), 2, "blue") ImageOps.fit(lena("L"), (128, 128)) ImageOps.fit(lena("RGB"), (128, 128)) ImageOps.fit(lena("RGB").resize((1, 1)), (35, 35)) ImageOps.flip(lena("L")) ImageOps.flip(lena("RGB")) ImageOps.grayscale(lena("L")) ImageOps.grayscale(lena("RGB")) ImageOps.invert(lena("L")) ImageOps.invert(lena("RGB")) ImageOps.mirror(lena("L")) ImageOps.mirror(lena("RGB")) ImageOps.posterize(lena("L"), 4) ImageOps.posterize(lena("RGB"), 4) ImageOps.solarize(lena("L")) ImageOps.solarize(lena("RGB")) success()
def imgprocforsingle(imgsize, imgid): """processing image into multiple [forced] resolution""" imgdata = db.image.find_one({'_id': ObjectId(imgid)}) buf = StringIO() path = os.getcwd() path = path + "/app/walls/img/" im = Image.open(path + imgdata['filename']) # crop size = imgdata['dims'] im = im.crop((11, 15, size[0]-8, size[1]-18)) # mirror im = ImageOps.mirror(im) # rotate # detail im = im.filter(ImageFilter.DETAIL) # edge enhance #im = im.filter(ImageFilter.EDGE_ENHANCE_MORE) # unsharp mask im = im.filter(ImageFilter.UnsharpMask) # smooth im = im.filter(ImageFilter.SMOOTH_MORE) # sharper im = im.filter(ImageFilter.SHARPEN) # RGB im = ImageEnhance.Color(im).enhance(1.2) # resize here dims = [int(i) for i in imgsize.split('x')] im.thumbnail((dims), Image.ANTIALIAS) im.save(buf, format="JPEG") imgstring = buf.getvalue() response = make_response(imgstring) response.headers['Content-Type'] = 'image/jpeg' response.headers['Cache-Control'] = 'public, max-age=43200' response.headers['Content-Disposition'] = 'inline; filename=sedecor.jpg' return response
def apply_mirror(pixbuf): ''' image left to right ''' width,height = pixbuf.get_width(),pixbuf.get_height() y = ImageOps.mirror(Image.frombytes(K.ImageConstants.RGB_SHORT_NAME,(width,height),pixbuf.get_pixels() )) return I.fromImageToPixbuf(y)
def processImage(self,fileName): imPath = os.path.join(self.picdir,fileName) print ('imPath', imPath) im = Image.open(imPath) w,h = im.size im = ImageOps.mirror(im) pix = im.load() output = [] for i in range(64*32): output.append(0) if w != 32: print('invalid image width, should be 32 px') if h != 64: print('invalid image height, should be 64 px') for y in range(64): for x in range(32): pixelVal = pix[x,y] val = int(round(self.compute(pixelVal))) output[y*32+x] = val frameName = fileName.split('.')[0] self.outputText += 'static unsigned int '+frameName+'[2048] = {' for val in output: self.outputText += str(val)+', ' self.outputText = self.outputText[:-2]+'};\n'
def mirror_image(image_path): img = Image.open(image_path) mirror_img = ImageOps.mirror(img) image_name = image_path.split('/')[-1] fh = 'data/' + split fh = os.path.join(fh, image_name) mirror_img.save(fh, "JPEG")
def generate_tile_image(img, tile): # tile the image horizontally (x2 is enough), # some cards need to wrap around to create a bar (e.g. Muster for Battle), # also discard alpha channel (e.g. Soulfire, Mortal Coil) tiled = Image.new("RGB", (img.width * 2, img.height)) tiled.paste(img, (0, 0)) tiled.paste(img, (img.width, 0)) x, y, width, height = get_rect( tile["m_TexEnvs"]["_MainTex"]["m_Offset"]["x"], tile["m_TexEnvs"]["_MainTex"]["m_Offset"]["y"], tile["m_TexEnvs"]["_MainTex"]["m_Scale"]["x"], tile["m_TexEnvs"]["_MainTex"]["m_Scale"]["y"], tile["m_Floats"].get("_OffsetX", 0.0), tile["m_Floats"].get("_OffsetY", 0.0), tile["m_Floats"].get("_Scale", 1.0), img.width ) bar = tiled.crop((x, y, x + width, y + height)) bar = ImageOps.flip(bar) # negative x scale means horizontal flip if tile["m_TexEnvs"]["_MainTex"]["m_Scale"]["x"] < 0: bar = ImageOps.mirror(bar) return bar.resize((OUT_WIDTH, OUT_HEIGHT), Image.LANCZOS)
def determineDirection(a, b, c, d, figures): if min(a, b) > min(c, d): result = ImageOps.mirror(openAndInvert(figures[6])) optimal = min(a, b) else: result = ImageOps.flip(openAndInvert(figures[2])) optimal = min(c, d) return result, optimal
def _mirror_images(process_me): """ Mirrors the given images horizontally. """ results = [] for orig_im in process_me: results.append(orig_im) results.append(ImageOps.mirror(orig_im)) return results
def gen_trans(imgfile,trans,outfile): for trans in trans.split('*'): image = Image.open(imgfile) w,h = image.size if trans=="plain": image.save(outfile,"JPEG",quality=100) elif trans=="flip": ImageOps.mirror(image).save(outfile,"JPEG",quality=100) elif trans.startswith("crop"): c = int(trans[4:]) image.crop(gen_crop(c,w,h)).save(outfile,"JPEG",quality=100) elif trans.startswith("h**o"): c = int(trans[4:]) image.transform((w,h),Image.QUAD, gen_homo(c,w,h), Image.BILINEAR).save(outfile,"JPEG",quality=100) elif trans.startswith("jpg"): image.save(outfile,quality=int(trans[3:])) elif trans.startswith("scale"): scale = SCALES[int(trans.replace("scale",""))] image.resize((int(w/scale),int(h/scale)),Image.BILINEAR).save(outfile,"JPEG",quality=100) elif trans.startswith('color'): (dr,dg,db) = gen_colorimetry(int(trans[5])) table = numpy.tile(numpy.arange(256),(3)) table[ :256]+= dr table[256:512]+= dg table[512: ]+= db image.convert("RGB").point(table).save(outfile,"JPEG",quality=100) elif trans.startswith('rot-'): angle =int(trans[4:]) for i in range(angle): image = rot(image,-1,outfile) image.save(outfile,"JPEG",quality=100) elif trans.startswith('rot'): angle =int(trans[3:]) for i in range(angle): image = rot(image,1,outfile) image.save(outfile,"JPEG",quality=100) elif trans.startswith('corner'): i = int(trans[6:]) image.crop(gen_corner(i,w,h)).save(outfile,"JPEG",quality=100) else: assert False, "Unrecognized transformation: "+trans imgfile = outfile # in case we iterate
def MirrorImage_windows(self): # print ("8") global img global PILimg global edit print (PILimg) PILimg=ImageOps.mirror(PILimg)# convert image to a Mirror Image PILimg.show() PILimg.save("/Users/DANADEVOST/Desktop/PYTHON_FOLDER/GIF_IMAGES/testMIRROR.gif", format=None)
def mirror_and_export(im, r, c, w, h, out_file): # exploit mirror symmetry of the face # flip image im = np.asarray(ImageOps.mirror(Image.fromarray(im))) # flip column coordinate of the object c = im.shape[1] - c # export export(im, r, c, w, h, out_file)
def operations(self): """Perform enhancements from the ImageOps class. """ if self.effect == 'flip': to_save = ImageOps.flip(self.image) if self.effect == 'mirror': to_save = ImageOps.mirror(self.image) if self.effect == 'grayscale': to_save = ImageOps.grayscale(self.image) to_save.save(self.new_file) return self.return_path
def process(self, image): """ @param image -- The image to process. Returns a single image, or a list containing one or more images. """ BaseFilter.process(self, image) newImage = ImageOps.mirror(image) if not self.both: return newImage else: return [image, newImage]
def crop_mirror(original, left, upper, right, lower, dir_path, prefix, frame_path): # crop cropped_frame = original.crop((left, upper, right, lower)) crop_path = os.path.join(dir_path, prefix + frame_path) cropped_frame.save(crop_path, quality=95) assert cropped_frame.size == (224, 224) # mirror mirrored_frame = ImageOps.mirror(cropped_frame) mirror_path = os.path.join(dir_path, prefix + "m_" + frame_path) mirrored_frame.save(mirror_path, quality=95) assert mirrored_frame.size == (224, 224)
def resize_image(self, src, dst, max_size, bigger_panoramas=True, preserve_exif_data=False, exif_whitelist={}): """Make a copy of the image in the requested size.""" if not Image or os.path.splitext(src)[1] in ['.svg', '.svgz']: self.resize_svg(src, dst, max_size, bigger_panoramas) return im = Image.open(src) size = w, h = im.size if w > max_size or h > max_size: size = max_size, max_size # Panoramas get larger thumbnails because they look *awful* if bigger_panoramas and w > 2 * h: size = min(w, max_size * 4), min(w, max_size * 4) try: exif = piexif.load(im.info["exif"]) except KeyError: exif = None # Inside this if, we can manipulate exif as much as # we want/need and it will be preserved if required if exif is not None: # Rotate according to EXIF value = exif['0th'].get(piexif.ImageIFD.Orientation, 1) if value in (3, 4): im = im.rotate(180) elif value in (5, 6): im = im.rotate(270) elif value in (7, 8): im = im.rotate(90) if value in (2, 4, 5, 7): im = ImageOps.mirror(im) exif['0th'][piexif.ImageIFD.Orientation] = 1 try: im.thumbnail(size, Image.ANTIALIAS) if exif is not None and preserve_exif_data: # Put right size in EXIF data w, h = im.size if '0th' in exif: exif["0th"][piexif.ImageIFD.ImageWidth] = w exif["0th"][piexif.ImageIFD.ImageLength] = h if 'Exif' in exif: exif["Exif"][piexif.ExifIFD.PixelXDimension] = w exif["Exif"][piexif.ExifIFD.PixelYDimension] = h # Filter EXIF data as required exif = self.filter_exif(exif, exif_whitelist) im.save(dst, exif=piexif.dump(exif)) else: im.save(dst) except Exception as e: self.logger.warn("Can't process {0}, using original " "image! ({1})".format(src, e)) utils.copy_file(src, dst)
def gen_key_img(mappings, size=0, color=None): base_img = Image.open(BytesIO(KEY_IMAGE_DATA)) if isinstance(size, tuple): key_width, key_height = size else: key_width, key_height = KEY_SIZES[size] center_x = key_width // 2 top = base_img.crop((16, 0, 32, 32)) bottom = base_img.crop((16, 32, 32, 64)) left = base_img.crop((0, 16, 16, 32)) top_left = base_img.crop((0, 0, 32, 32)) bottom_left = base_img.crop((0, 32, 32, 64)) key_img = Image.new('RGBA', size=(key_width, key_height)) for offset in range(32, center_x, 16): paste(key_img, top, (offset, 0)) paste(key_img, bottom, (offset, -32)) for offset in range(32, key_height - 16, 16): paste(key_img, left, (0, offset)) paste(key_img, top_left, (0, 0)) paste(key_img, bottom_left, (0, -32)) mirrored = key_img.crop((0, 0, center_x, key_height)) mirrored = ImageOps.mirror(mirrored) paste(key_img, mirrored, (center_x, 0)) bg_img = Image.new('RGBA', size=(key_width, key_height)) draw = ImageDraw.Draw(bg_img) if color: draw.rectangle([(8, 8), (key_width - 8, key_height - 8)], color) for (rel_x, rel_y, color), mapping in zip(KEY_TEXT_REL_POS, mappings): key_text = mapping.raw_code if key_text.isupper() and len(key_text) > 1 and key_text.lower() not in KEY_TEXT_SYMBOLS: print(key_text.lower()) key_text = KEY_TEXT_SYMBOLS.get(key_text.lower(), key_text) text_width, text_height = draw.textsize(key_text, font=font) text_x_pos = key_width * rel_x - text_width // 2 text_y_pos = key_height * rel_y - text_height // 2 draw.text( (text_x_pos, text_y_pos), key_text, font=font, fill=color, ) del draw paste(bg_img, key_img) return bg_img
def applyflip(self, image): if self.rotationflip == 0: return image elif self.rotationflip == 1: return image.rotate(90) elif self.rotationflip == 2: return image.rotate(180) elif self.rotationflip == 3: return image.rotate(270) elif self.rotationflip == 4: return ImageOps.mirror(image) elif self.rotationflip == 5: return ImageOps.flip(image)
def flip_horizontal(images, uv_pixel_positions): """ Randomly flip the image and the pixel positions horizontall (flip left/right) See random_image_and_indices_mutation() for documentation of args and return types. """ mutated_images = [ImageOps.mirror(image) for image in images] u_pixel_positions = uv_pixel_positions[0] mutated_u_pixel_positions = (image.width-1) - u_pixel_positions mutated_uv_pixel_positions = (mutated_u_pixel_positions, uv_pixel_positions[1]) return mutated_images, mutated_uv_pixel_positions
def exportmirrored(im, r, c, s, folder, id, list): # # exploit mirror symmetry of the face # # flip image im = numpy.asarray(ImageOps.mirror(Image.fromarray(im))) # flip column coordinate of the object c = im.shape[1] - c # export export(im, r, c, s, folder, id, list)
def capturePreview(self): if self._is_preview: while self._comm.empty(Workers.CAMERA): picture = self._cap.getPreview() if self._rotation is not None: picture = picture.transpose(self._rotation) picture = picture.resize(self._pic_dims.previewSize) picture = ImageOps.mirror(picture) byte_data = BytesIO() picture.save(byte_data, format='jpeg') self._comm.send(Workers.GUI, StateMachine.CameraEvent('preview', byte_data))
def handle(self, header, data): # PERFORM Cognitive Assistant Processing sys.stdout.write("processing: ") sys.stdout.write("%s\n" % header) image = Image.open(io.BytesIO(data)) mirror_image=ImageOps.mirror(image) mirror_output = StringIO.StringIO() mirror_image.save(mirror_output, 'JPEG') jpeg_image = mirror_output.getvalue() result = base64.b64encode(jpeg_image) mirror_output.close() return result
def horizontalReflection(image1, image2): neg_image1 = convertImage(image1) neg_image2 = convertImage(image2) reflected_image1 = ImageOps.mirror(neg_image1) diff = ImageChops.difference(reflected_image1, neg_image2) stat = ImageStat.Stat(diff) mean = stat.mean[0] if mean < 1.0: print ("Horizontal Reflection Function: Reflected Horizontally") return True else: print ("Horizontal Reflection Function: Not reflected horizontally") return False
def craft(self, blob, doc_id, *args, **kwargs): raw_img = self.load_image(blob) _img = ImageOps.mirror(raw_img) img = self.restore_channel_axis(np.asarray(_img)) return [{'doc_id': doc_id, 'blob': img.astype('float32')}, ]
def updateDisplay(config, pricestack, whichcoin): pricenow = pricestack[-1] currencythumbnail = 'currency/' + whichcoin + '.bmp' tokenimage = Image.open(os.path.join(picdir, currencythumbnail)) sparkbitmap = Image.open(os.path.join(picdir, 'spark.bmp')) if config['ticker']['hidden'] == True: if config['display']['orientation'] == 0 or config['display'][ 'orientation'] == 180: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.width, epd.height), 255) # 255: clear the image with white image.paste(tokenimage, (10, 20)) draw = ImageDraw.Draw(image) draw.text((5, 200), "1 " + whichcoin, font=fonthiddenprice, fill=0) draw.text((0, 10), str(time.strftime("%c")), font=font_date, fill=0) if config['display']['orientation'] == 180: image = image.rotate(180, expand=True) if config['display']['orientation'] == 90 or config['display'][ 'orientation'] == 270: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.height, epd.width), 255) # 255: clear the image with white image.paste(tokenimage, (0, 0)) draw = ImageDraw.Draw(image) draw.text((20, 120), "1 " + whichcoin, font=fontHorizontal, fill=0) draw.text((85, 5), str(time.strftime("%c")), font=font_date, fill=0) if config['display']['orientation'] == 270: image = image.rotate(180, expand=True) # This is a hack to deal with the mirroring that goes on in 4Gray Horizontal image = ImageOps.mirror(image) else: # Get the numbers pricechange = str("%+d" % round( (pricestack[-1] - pricestack[0]) / pricestack[-1] * 100, 2)) + "%" if pricenow > 1000: pricenowstring = format(int(pricenow), ",") else: pricenowstring = str(float('%.5g' % pricenow)) if config['display']['orientation'] == 0 or config['display'][ 'orientation'] == 180: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.width, epd.height), 255) # 255: clear the image with white draw = ImageDraw.Draw(image) draw.text((110, 80), "7day :", font=font_date, fill=0) draw.text((110, 95), pricechange, font=font_date, fill=0) # Print price to 5 significant figures draw.text((5, 200), "$" + pricenowstring, font=font, fill=0) draw.text((0, 10), str(time.strftime("%c")), font=font_date, fill=0) image.paste(tokenimage, (10, 25)) image.paste(sparkbitmap, (10, 125)) if config['display']['orientation'] == 180: image = image.rotate(180, expand=True) if config['display']['orientation'] == 90 or config['display'][ 'orientation'] == 270: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.height, epd.width), 255) # 255: clear the image with white draw = ImageDraw.Draw(image) draw.text((100, 100), "7day : " + pricechange, font=font_date, fill=0) # Print price to 5 significant figures draw.text((20, 120), "$" + pricenowstring, font=fontHorizontal, fill=0) image.paste(sparkbitmap, (80, 50)) image.paste(tokenimage, (0, 0)) draw.text((85, 5), str(time.strftime("%c")), font=font_date, fill=0) if config['display']['orientation'] == 270: image = image.rotate(180, expand=True) # This is a hack to deal with the mirroring that goes on in 4Gray Horizontal image = ImageOps.mirror(image) # If the display is inverted, invert the image usinng ImageOps if config['display']['inverted'] == True: image = ImageOps.invert(image) # Send the image to the screen epd.display_4Gray(epd.getbuffer_4Gray(image)) epd.sleep()
def __call__(self, img, anno_class_img): if np.random.randint(2): img = ImageOps.mirror(img) anno_class_img = ImageOps.mirror(anno_class_img) return img, anno_class_img
i = 0 files2 = [ 'data/images/Covid/'+f for f in listdir('data/images/Covid') if isfile(join('data/images/Covid', f))] files3 = [ 'data/images/NORMAL/'+f for f in listdir('data/images/NORMAL') if isfile(join('data/images/NORMAL', f))] j = 0 k = 0 for f in files: try: pic = Image.open(f) im = ImageOps.fit(pic,(128,128),method=3, bleed=0.0, centering=(0.5, 0.5)) imArray1 = np.array(im) im = ImageOps.mirror(im) imArray2 = np.array(im) im = ImageOps.fit(pic,(128,128),method=3, bleed=0.0, centering=(0.5, 0.5)) im = ImageOps.solarize(im,threshold=128) imArray3 = np.array(im) im = ImageOps.mirror(im) imArray4 = np.array(im) except Exception: print('error image') pass else: if not(f in list):
def mirrorImage(initialPath): im = Image.open(initialPath) return ImageOps.mirror(im)
def _draw_image(self, gcode, include_rapids): # size of the image (should be based on the max path point) scale = self._image_size() if self.transparency: img = Image.new('RGBA', self.image_size, (255, 0, 0, 0)) else: img = Image.new('RGB', self.image_size, self.background) draw = ImageDraw.Draw(img) # draw centreline cl_y = (self.image_size[1] / 2 - self._min_y) start = (self.margin * 0.25, cl_y) end = (self.image_size[0] - self.margin * 0.5, cl_y) draw.line([start, end], fill=(252, 226, 5), width=self.line_thickness * 2) for idx, command in enumerate(gcode): if idx < len(gcode) - 1: movement = command.get_movement() if movement not in ["G0", "G1", "G2", "G3"]: continue if movement == "G0" and not include_rapids: continue params = command.get_params() prev_params = gcode[idx - 1].get_params() line_colour = self._get_line_colour(movement) x_start = (prev_params['Z'] - self._min_x) * scale + self.margin / 2 y_start = (prev_params['X'] - self._min_y) * scale + self.margin / 2 x_end = (params['Z'] - self._min_x) * scale + self.margin / 2 y_end = (params['X'] - self._min_y) * scale + self.margin / 2 if movement in ["G0", "G1"]: draw.line([(x_start, y_start), (x_end, y_end)], fill=line_colour, width=self.line_thickness) if movement in ["G2", "G3"]: x_centre = (prev_params['Z'] + params['K'] - self._min_x) * scale + self.margin / 2 y_centre = (prev_params['X'] + params['I'] - self._min_y) * scale + self.margin / 2 distance = self._get_distance(x_centre, y_centre, x_start, y_start) start_angle = self._get_angle(x_centre, y_centre, x_start, y_start) end_angle = self._get_angle(x_centre, y_centre, x_end, y_end) boundbox = [(x_centre - distance, y_centre - distance), (x_centre + distance, y_centre + distance)] if movement == "G2": draw.arc(boundbox, end_angle, start_angle, fill=line_colour, width=self.line_thickness) if movement == "G3": draw.arc(boundbox, start_angle, end_angle, fill=line_colour, width=self.line_thickness) # Mirror because its draw flipped. if self.mirror_image: img = ImageOps.mirror(img) elif self.flip_image: img = ImageOps.flip(img) else: img = ImageOps.flip(img) if self.transparency: img.save(self.file_location + self.image_name + '.png') else: img.save(self.file_location + self.image_name + self.image_type)
origin = Image.open('body_light.png') else: origin = Image.open('body.png') if flinz: print("Apply LINZ Correction") pantie = pantie.resize((629, 407)) origin.paste(pantie, (1017, 828), pantie) origin_transparent = Image.new("RGBA", (origin.size)) origin_transparent.paste(pantie, (1017, 828), pantie) origin_transparent.save('patched_transparent.png') elif fnbody: print("!nbody_mode!") cut = 7 right_pantie = pantie.crop((cut, 0, pantie.size[0], pantie.size[1])) left_pantie = ImageOps.mirror(right_pantie) npantie = Image.new("RGBA", (right_pantie.size[0] * 2, right_pantie.size[1])) npantie.paste(right_pantie, (right_pantie.size[0], 0)) npantie.paste(left_pantie, (0, 0)) origin.paste(npantie, (403, 836), npantie) origin_transparent = Image.new("RGBA", (origin.size)) origin_transparent.paste(npantie, (403, 836), npantie) origin_transparent.save('patched_transparent.png') elif flight: print("Apply Quiche_Light Conversion") pantie = pantie.resize((236, 157)) origin.paste(pantie, (532, 385), pantie) origin_transparent = Image.new("RGBA", (origin.size)) origin_transparent.paste(pantie, (532, 385), pantie)
def imageTransforms(image, type=None, param=0.1): """get transformed image Arguments: image {PIL.Image|str} -- input image or url Keyword Arguments: type {str} -- whether image is a url or PIL.Image (default: {None}) param {float} -- parameter for controlling different transforms (default: {0.1}) Returns: [type] -- [description] """ from PIL import Image, ImageFilter, ImageOps, ImageChops from torchvision.transforms import Grayscale, ColorJitter from random import uniform # PIL can convert across formats # PIL is a good library brent 11/10 # https://pillow.readthedocs.io/en/3.3.x/reference/Image.html # All ImageFilters: ['BLUR', 'CONTOUR', 'DETAIL', 'EDGE_ENHANCE', 'EDGE_ENHANCE', 'EDGE_ENHANCE_MORE', 'EMBOSS', 'FIND_EDGES', 'SMOOTH', 'SMOOTH_MORE', 'SHARPEN', 'GaussianBlur', 'UnsharpMask', 'RankFilter', 'MedianFilter', 'MinFilter', 'MaxFilter', 'ModeFilter'] imagefilters = [ 'BLUR', 'CONTOUR', 'DETAIL', 'EDGE_ENHANCE', 'EDGE_ENHANCE', 'EDGE_ENHANCE_MORE', 'EMBOSS', 'FIND_EDGES', 'SMOOTH', 'SMOOTH_MORE', 'SHARPEN', 'GaussianBlur(radius=param)', 'UnsharpMask', 'RankFilter', 'MedianFilter(size=int(param))', 'MinFilter(size=int(param))', 'MaxFilter(size=int(param))', 'ModeFilter(size=int(param))' ] # imageops as preprocessing: autocontrast, colorize, equalize imageops = ['invert', 'mirror', 'posterize', 'solarize'] # ImageEnhance? # torchvision.transforms : https://pytorch.org/docs/stable/torchvision/transforms.html # TODO: try other torchvision transforms torchtransforms = ['ColorJitter', 'Grayscale'] if type == 'crop': bounds = list(image.getbbox()) # sides = sample(range(2, 4), 2) bounds[2] = int(bounds[2] * (1 - (uniform(0, param)))) bounds[3] = int(bounds[3] * (1 - (uniform(0, param)))) image = image.crop(tuple(bounds)) return image elif type == 'rotate': # angle = sample(range(30, 330, 30), 1)[0] angle = param image = image.rotate(angle) return image elif type in imagefilters: image = image.filter(eval(f'ImageFilter.{type}')) return image elif type == 'invert': image = ImageOps.invert(image) return image elif type == 'grayscale': image = Grayscale(num_output_channels=3)(image) return image elif type == 'mirror': image = ImageOps.mirror(image) return image elif type == 'color_jitter': # TODO: convert return to PIL.image image = ColorJitter()(image) image = Image.fromarray(image) else: print(f'{type} transform not found') return image
def mirror_image(image): """ Returns a copy of the given image flipped horizontally. """ return ImageOps.mirror(image)
def solve2x2(self, problem): retVal = -1 imageDictionary = {} figuresDictionary = {} for name in ['A', 'B', 'C', '1', '2', '3', '4', '5', '6']: imageDictionary[name] = Image.open( problem.figures[name].visualFilename) figuresDictionary[name] = toNumpyMatrix(imageDictionary[name]) solutionsDictionary = { k: figuresDictionary[k] for k in figuresDictionary.keys() & {'1', '2', '3', '4', '5', '6'} } hMirrorA = toNumpyMatrix(ImageOps.mirror(imageDictionary['A'])) hMirrorB = toNumpyMatrix(ImageOps.mirror(imageDictionary['B'])) hMirrorC = toNumpyMatrix(ImageOps.mirror(imageDictionary['C'])) vMirrorA = toNumpyMatrix(ImageOps.flip(imageDictionary['A'])) vMirrorB = toNumpyMatrix(ImageOps.flip(imageDictionary['B'])) vMirrorC = toNumpyMatrix(ImageOps.flip(imageDictionary['C'])) if retVal == -1: # A == B retVal = equate2x2(figuresDictionary, solutionsDictionary, figuresDictionary['A'], figuresDictionary['B'], figuresDictionary['C']) if retVal == -1: # A == C retVal = equate2x2(figuresDictionary, solutionsDictionary, figuresDictionary['A'], figuresDictionary['C'], figuresDictionary['B']) if retVal == -1: # A horizontal mirror B retVal = equate2x2(figuresDictionary, solutionsDictionary, hMirrorA, figuresDictionary['B'], hMirrorC) if retVal == -1: # A horizontal mirror C retVal = equate2x2(figuresDictionary, solutionsDictionary, hMirrorA, figuresDictionary['C'], hMirrorB) if retVal == -1: # A vertical mirror B retVal = equate2x2(figuresDictionary, solutionsDictionary, vMirrorA, figuresDictionary['B'], vMirrorC) if retVal == -1: # A vertical mirror C retVal = equate2x2(figuresDictionary, solutionsDictionary, vMirrorA, figuresDictionary['C'], vMirrorB) if retVal == -1: # A is outline of B solid retVal = equate2x2(figuresDictionary, solutionsDictionary, figuresDictionary['A'], figuresDictionary['B'], figuresDictionary['C'], 0.96, 0.90) if retVal == -1: # A is outline of C solid retVal = equate2x2(figuresDictionary, solutionsDictionary, figuresDictionary['A'], figuresDictionary['C'], figuresDictionary['B'], 0.96, 0.90) if retVal == -1: # Rotate image degrees = [-45, -90, -135, -180, -225, -270, -315] background = Image.new('RGBA', imageDictionary['A'].size, 'white') for angle in degrees: #print ("Rotate Image ", angle, " degrees") RotateA = imageDictionary['A'].rotate(angle) RotateB = imageDictionary['B'].rotate(angle) RotateC = imageDictionary['C'].rotate(angle) rotateA = toNumpyMatrix( Image.composite(RotateA, background, RotateA)) rotateB = toNumpyMatrix( Image.composite(RotateB, background, RotateB)) rotateC = toNumpyMatrix( Image.composite(RotateC, background, RotateC)) if retVal == -1: # A horizontal mirror B similarA, meanA, rmsA, bboxA = diffStatistics( rotateA, figuresDictionary['B']) #print ("A rotated ",angle," degrees to B mean=",meanA," rms=",rmsA," diff=",abs(meanA-rmsA)) retVal = equate2x2(figuresDictionary, solutionsDictionary, rotateA, figuresDictionary['B'], rotateC) if retVal == -1: # A horizontal mirror C similarA, meanA, rmsA, bboxA = diffStatistics( rotateA, figuresDictionary['C']) #print ("A rotated ",angle," degrees to C mean=",meanA," rms=",rmsA," diff=",abs(meanA-rmsA)) retVal = equate2x2(figuresDictionary, solutionsDictionary, rotateA, figuresDictionary['C'], rotateB) if retVal > 0: break if retVal == -1: retVal = randint(1, 6) return retVal
def solve3x3(self, problem): retVal = -1 imageDictionary = {} figuresDictionary = {} for name in [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', '1', '2', '3', '4', '5', '6', '7', '8' ]: imageDictionary[name] = Image.open( problem.figures[name].visualFilename) figuresDictionary[name] = toNumpyMatrix(imageDictionary[name]) solutionsDictionary = { k: figuresDictionary[k] for k in figuresDictionary.keys() & {'1', '2', '3', '4', '5', '6', '7', '8'} } hMirrorA = toNumpyMatrix(ImageOps.mirror(imageDictionary['A'])) hMirrorB = toNumpyMatrix(ImageOps.mirror(imageDictionary['B'])) hMirrorC = toNumpyMatrix(ImageOps.mirror(imageDictionary['C'])) hMirrorD = toNumpyMatrix(ImageOps.mirror(imageDictionary['D'])) hMirrorE = toNumpyMatrix(ImageOps.mirror(imageDictionary['E'])) hMirrorF = toNumpyMatrix(ImageOps.mirror(imageDictionary['F'])) hMirrorG = toNumpyMatrix(ImageOps.mirror(imageDictionary['G'])) hMirrorH = toNumpyMatrix(ImageOps.mirror(imageDictionary['H'])) vMirrorA = toNumpyMatrix(ImageOps.flip(imageDictionary['A'])) vMirrorB = toNumpyMatrix(ImageOps.flip(imageDictionary['B'])) vMirrorC = toNumpyMatrix(ImageOps.flip(imageDictionary['C'])) vMirrorD = toNumpyMatrix(ImageOps.flip(imageDictionary['D'])) vMirrorE = toNumpyMatrix(ImageOps.flip(imageDictionary['E'])) vMirrorF = toNumpyMatrix(ImageOps.flip(imageDictionary['F'])) vMirrorG = toNumpyMatrix(ImageOps.flip(imageDictionary['G'])) vMirrorH = toNumpyMatrix(ImageOps.flip(imageDictionary['H'])) if retVal == -1: # A == B == C similar1, mean1, rms1, bbox1 = diffStatistics( figuresDictionary['A'], figuresDictionary['B']) similar2, mean2, rms2, bbox2 = diffStatistics( figuresDictionary['B'], figuresDictionary['C']) bestMeanDiff = 1 if similar1 and similar2: for key, value in solutionsDictionary.items(): similar, mean, rms, bbox = diffStatistics( figuresDictionary['G'], value) if similar and abs(mean - mean1) < bestMeanDiff: bestMeanDiff = abs(mean - mean1) retVal = int(key) if retVal == -1: # A == D == G similar1, mean1, rms1, bbox1 = diffStatistics( figuresDictionary['A'], figuresDictionary['D']) similar2, mean2, rms2, bbox2 = diffStatistics( figuresDictionary['D'], figuresDictionary['G']) bestMeanDiff = 1 if similar1 and similar2: for key, value in solutionsDictionary.items(): similar, mean, rms, bbox = diffStatistics( figuresDictionary['C'], value) if similar and abs(mean - mean1) < bestMeanDiff: bestMeanDiff = abs(mean - mean1) retVal = int(key) if retVal == -1: # percentage similar1, mean1, rms1, bbox1 = diffStatistics( figuresDictionary['A'], figuresDictionary['B']) similar2, mean2, rms2, bbox2 = diffStatistics( figuresDictionary['B'], figuresDictionary['C']) similar12, mean12, rms12, bbox12 = diffStatistics( figuresDictionary['A'], figuresDictionary['C']) similar3, mean3, rms3, bbox3 = diffStatistics( figuresDictionary['D'], figuresDictionary['E']) similar4, mean4, rms4, bbox4 = diffStatistics( figuresDictionary['E'], figuresDictionary['F']) similar34, mean34, rms34, bbox34 = diffStatistics( figuresDictionary['D'], figuresDictionary['F']) similar5, mean5, rms5, bbox5 = diffStatistics( figuresDictionary['G'], figuresDictionary['H']) similar1, mean6, rms6, bbox1 = diffStatistics( figuresDictionary['A'], figuresDictionary['D']) similar2, mean7, rms7, bbox2 = diffStatistics( figuresDictionary['D'], figuresDictionary['G']) similar3, mean8, rms8, bbox3 = diffStatistics( figuresDictionary['B'], figuresDictionary['E']) similar4, mean9, rms9, bbox4 = diffStatistics( figuresDictionary['E'], figuresDictionary['H']) similar5, mean0, rms0, bbox5 = diffStatistics( figuresDictionary['C'], figuresDictionary['F']) rms1 = round(rms1, 3) rms2 = round(rms2, 3) rms12 = round(rms12, 3) rms3 = round(rms3, 3) rms4 = round(rms4, 3) rms34 = round(rms34, 3) rms5 = round(rms5, 3) rms6 = round(rms6, 3) rms7 = round(rms7, 3) rms8 = round(rms8, 3) rms9 = round(rms9, 3) rms0 = round(rms0, 3) k = round(rms2 - rms0, 3) j = round(rms7 - rms5, 3) for key, value in solutionsDictionary.items(): similar, meana, rmsa, bbox = diffStatistics( figuresDictionary['F'], value) similar, meanb, rmsb, bbox = diffStatistics( figuresDictionary['H'], value) rmsa = round(rmsa, 3) rmsb = round(rmsb, 3) if (meana == round(mean0 - k, 2) and meanb == round(mean5 - j, 2)): retVal = int(key) return retVal
for chunk in r.iter_content(chunk_size=1024): raw_bytes += chunk a = raw_bytes.find(b'\xff\xd8\xff') b = raw_bytes.find(b'\xff\xd9',a) if a != -1 and b != -1: jpg = raw_bytes[a:b+2] raw_bytes = raw_bytes[b+2:] imgIo=io.BytesIO(jpg) img=Image.open(imgIo) # cvImg=cv2.cvtColor(np.array(img.convert("RGB")),cv2.COLOR_RGB2BGR) c+=1 c=c % 5 if(c==0): processing.useImg(np.array(ImageOps.mirror(ImageOps.flip(img))),mc) else: print("INVALID CODE CAN'T PROCEED")
def imageInflated(_inImportPath, _inExportPath): files = os.listdir(_inImportPath) imgNum = 0 for file in files: index = re.search('.png',file) if index: imgNum += 1 print(imgNum) for i in range(imgNum): importImagePath = os.path.join(_inImportPath,str(i+1)+'.png') im_0 = Image.open(importImagePath) saveImage(im_0,_inExportPath) im_1 = ImageOps.mirror(im_0) saveImage(im_1,_inExportPath) im_2 = im_0.point(lambda x:x * 1.3) saveImage(im_2,_inExportPath) im_3 = im_1.point(lambda x:x * 1.3) saveImage(im_3,_inExportPath) im_4 = im_0.point(lambda x:x * 0.7) saveImage(im_4,_inExportPath) im_5 = im_1.point(lambda x:x * 0.7) saveImage(im_5,_inExportPath) im_6 = changeColorRate(im_0,1.2,1,1) saveImage(im_6,_inExportPath) im_8 = changeColorRate(im_1,1.2,1,1) saveImage(im_8,_inExportPath) im_7 = changeColorRate(im_0,0.8,1,1) saveImage(im_7,_inExportPath) im_9 = changeColorRate(im_1,0.8,1,1) saveImage(im_9,_inExportPath) im_10 = changeColorRate(im_0,1,1.2,1) saveImage(im_10,_inExportPath) im_12 = changeColorRate(im_1,1,1.2,1) saveImage(im_12,_inExportPath) im_11 = changeColorRate(im_0,1,0.8,1) saveImage(im_11,_inExportPath) im_13 = changeColorRate(im_1,1,0.8,1) saveImage(im_13,_inExportPath) im_14 = changeColorRate(im_0,1,1,1.2) saveImage(im_14,_inExportPath) im_16 = changeColorRate(im_1,1,1,1.2) saveImage(im_16,_inExportPath) im_15 = changeColorRate(im_0,1,1,0.8) saveImage(im_15,_inExportPath) im_17 = changeColorRate(im_1,1,1,0.8) saveImage(im_17,_inExportPath) iec_1 = ImageEnhance.Contrast(im_0) im_18 = iec_1.enhance(1.3) saveImage(im_18,_inExportPath) iec_2 = ImageEnhance.Contrast(im_1) im_19 = iec_2.enhance(1.3) saveImage(im_19,_inExportPath) iec_3 = ImageEnhance.Contrast(im_0) im_20 = iec_3.enhance(0.7) saveImage(im_20,_inExportPath) iec_4 = ImageEnhance.Contrast(im_1) im_21 = iec_4.enhance(0.7) saveImage(im_21,_inExportPath) iec_5 = ImageEnhance.Color(im_0) im_22 = iec_5.enhance(1.3) saveImage(im_22,_inExportPath) iec_6 = ImageEnhance.Color(im_1) im_23 = iec_6.enhance(1.3) saveImage(im_23,_inExportPath) iec_7 = ImageEnhance.Color(im_0) im_24 = iec_7.enhance(0.7) saveImage(im_24,_inExportPath) iec_8 = ImageEnhance.Color(im_1) im_25 = iec_8.enhance(0.7) saveImage(im_25,_inExportPath) iec_9 = ImageEnhance.Sharpness(im_0) im_26 = iec_9.enhance(2) saveImage(im_26,_inExportPath) iec_10 = ImageEnhance.Sharpness(im_1) im_27 = iec_10.enhance(2) saveImage(im_27,_inExportPath) iec_11 = ImageEnhance.Sharpness(im_0) im_28 = iec_11.enhance(0.3) saveImage(im_28,_inExportPath) iec_12 = ImageEnhance.Sharpness(im_1) im_29 = iec_12.enhance(0.3) saveImage(im_29,_inExportPath)
def mirror(self, img_pil, acc_numpy): ## image img_pil = ImageOps.mirror(img_pil) #invert image ## acc acc_numpy[1] = -acc_numpy[1] return img_pil, acc_numpy
from PIL import Image, ImageOps base_dir = "/home/workspace/data/IMG/" csv_file = pd.read_csv("../../data/driving_log.processed.1.csv") data_set = [] for i in csv_file.index: print("Number of data: \t{}\r".format(i + 1), end="") image_file_name = csv_file["image"][i] angle = csv_file["steering"][i] image = Image.open(base_dir + image_file_name.split("/")[-1]) flippedimage = ImageOps.mirror(image) new_name = base_dir + image_file_name.replace(".jpg", "_flip.jpg").split("/")[-1] flippedimage.save(new_name) new_angle = -1 * angle data_set.append([image_file_name, angle]) data_set.append([new_name, new_angle]) new_csv = pd.DataFrame(data_set, columns=["image", "steering"]) new_csv.to_csv("../../data/driving_log.processed.2.csv")
def updateDisplay(config, pricestack): BTC = pricestack[-1] bmp = Image.open(os.path.join(picdir, 'BTC.bmp')) bmp2 = Image.open(os.path.join(picdir, 'spark.bmp')) if config['ticker']['hidden'] == True: if config['display']['orientation'] == 0 or config['display'][ 'orientation'] == 180: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.width, epd.height), 255) # 255: clear the image with white image.paste(bmp, (10, 20)) draw = ImageDraw.Draw(image) draw.text((5, 200), "1 BTC", font=font, fill=0) draw.text((0, 10), str(time.strftime("%c")), font=font_date, fill=0) if config['display']['orientation'] == 180: image = image.rotate(180, expand=True) if config['display']['orientation'] == 90 or config['display'][ 'orientation'] == 270: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.height, epd.width), 255) # 255: clear the image with white image.paste(bmp, (0, 0)) draw = ImageDraw.Draw(image) draw.text((20, 120), "1 BTC", font=fontHorizontal, fill=0) draw.text((85, 5), str(time.strftime("%c")), font=font_date, fill=0) if config['display']['orientation'] == 270: image = image.rotate(180, expand=True) # This is a hack to deal with the mirroring that goes on in 4Gray Horizontal image = ImageOps.mirror(image) else: if config['display']['orientation'] == 0 or config['display'][ 'orientation'] == 180: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.width, epd.height), 255) # 255: clear the image with white draw = ImageDraw.Draw(image) draw.text((110, 80), "7day :", font=font_date, fill=0) draw.text( (110, 95), str("%+d" % round( (pricestack[-1] - pricestack[1]) / pricestack[-1] * 100, 2)) + "%", font=font_date, fill=0) draw.text((5, 200), "$" + format(int(round(BTC)), ","), font=font, fill=0) draw.text((0, 10), str(time.strftime("%c")), font=font_date, fill=0) image.paste(bmp, (10, 20)) image.paste(bmp2, (10, 125)) if config['display']['orientation'] == 180: image = image.rotate(180, expand=True) if config['display']['orientation'] == 90 or config['display'][ 'orientation'] == 270: epd = epd2in7.EPD() epd.Init_4Gray() image = Image.new('L', (epd.height, epd.width), 255) # 255: clear the image with white draw = ImageDraw.Draw(image) draw.text( (100, 100), "7day : " + str("%+d" % round( (pricestack[-1] - pricestack[1]) / pricestack[-1] * 100, 2)) + "%", font=font_date, fill=0) draw.text((20, 120), "$" + format(int(round(BTC)), ","), font=fontHorizontal, fill=0) image.paste(bmp2, (80, 50)) image.paste(bmp, (0, 0)) draw.text((85, 5), str(time.strftime("%c")), font=font_date, fill=0) if config['display']['orientation'] == 270: image = image.rotate(180, expand=True) # This is a hack to deal with the mirroring that goes on in 4Gray Horizontal image = ImageOps.mirror(image) # If the display is inverted, invert the image usinng ImageOps if config['display']['inverted'] == True: image = ImageOps.invert(image) # Send the image to the screen epd.display_4Gray(epd.getbuffer_4Gray(image)) epd.sleep()
def transform(self, i, image): # (_x, _y): random translation position _x = np.random.randint(0, self.x) _y = np.random.randint(0, self.y) # _angle : random rotation angle _angle = np.random.randint(0, self.angle) minw = float(image.width) * float(self.shrink_rw) minh = float(image.height)* float(self.shrink_rh) # (_w, _h) : random image_width and image_height self._w = int( np.random.randint(int(minw), image.width) ) self._h = int( np.random.randint(int(minh), image.height) ) print(" {} {} {} {}".format(_x, _y, self._w, self._h)) if i % 3 == 0: _angle = _angle * (-1) # Resize the image to (_w, _h) image = image.resize(size=(self._w, self._h), resample=Image.LANCZOS) # Rotate the image by _angle image = image.rotate(_angle, translate=(_x, _y), expand=True) if i % 3 == 0: print("CONTRAST {}".format(i)) image = ImageOps.autocontrast(image, self.contrast) if i % 4 == 0 and self.vflip == True: print("VERTICAL FLIP {}".format(i)) image = ImageOps.flip(image) if i % 5 == 0 and self.hflip == True: print("HORIZONTAL FLIP {}".format(i)) image = ImageOps.mirror(image) if i % 5 == 0: # Apply a simple AFFINE transformation to the image. xshift = int( abs(self.xshift) * self.width ) yshift = int( abs(self.yshift) * self.height ) # New width and height (_nw, _nh) for AFFINE transformation _nw = self._w + xshift _nh = self._h + yshift # Very simple coefficients fo AFFINE transformation coeffs = (1, self.xshift, 0, 0, 1, 0, 0, 0) # Inverting _xs flag. self.xshift = self.xshift * (-1) print("AFFINE {}".format(i)) image = image.transform((_nw, _nh), Image.AFFINE, coeffs, Image.BICUBIC) if i % 6 == 0 and self.sharpen == True: print("SHARPEN {}".format(i)) image = image.filter(ImageFilter.SHARPEN) if i % 8 == 0 and self.smooth == True: print("SMOOTH_MORE {}".format(i)) image = image.filter(ImageFilter.SMOOTH_MORE) if i % 9 == 0 and self.edge_enhance == True: print("EDGE_ENHANCE_MORE {}".format(i)) image = image.filter(ImageFilter.EDGE_ENHANCE_MORE) if i>0 and i % 11 == 0 and self.noise >0.0: print("NOISE {}".format(i)) image = self.inject_saultpepper_noise(image) return image
def cloudiness(InputFilePath): # -*- coding: utf-8 -*- from PIL import Image, ImageDraw, ImageOps, ImageFont import math from pvlib.location import Location import matplotlib.dates as mdate import pvlib import pandas as pd import datetime import glob import numpy as np from time import clock import copy from Converter import convert #Information: # #Code written by Marcus Klingebiel, Max-Planck-Institute for Meteorology #E-Mail: [email protected] # #PLEASE ASK BEFORE SHARING THIS CODE! # # #Preliminary version of the All-Sky Cloud Algorithms (ASCA) #The code is based on the analysis of every single pixel on a jpeg-Image. #The used Ski-Index and Brightness-Index base on Letu et al. (2014), Applied Optics, Vol. 53, No. 31. # # # #Marcus Klingebiel, March 2016 #Code eddited by Tobias Machnitzki #Email: [email protected] print("Calculating Cloudcoverage") #--------------------Settings------------------------------------------------------------------------------------------ debugger = False #if true, the program will print a message after each step TXTFile = False #if True, the program will generate a csv file with several information. Delimiter = ',' # imagefont_size = 20 #Sets the font size of everything written into the picture Radius_synop = False #If True: not the whole sky will be used, but just the 60 degrees from the middle on (like the DWD does with cloud covering) Save_image = False #If True: an image will be printed at output-location, where recognized clouds are collored. # font = ImageFont.truetype("/home/tobias/anaconda3/lib/python3.5/site-packages/matplotlib/mpl-data/fonts/ttf/Vera.ttf",imagefont_size) # Font set_scale_factor = 100 #this factor sets the acuracy of the program. By scaling down the image size the program gets faster but also its acuracy dercreases. #It needs to be between 1 and 100. If set 100, then the original size of the image will be used. #If set to 50 the image will be scaled down to half its size # #---------------------Calcutlate the SI-parameter-------------------------------------------------------------------------------------- #The Parameter gets calculated before the loop over all filse start, to save computing time. #To see how the function for the parameter was generated, see the documentation. size = 100 parameter = np.zeros(size) for j in range(size): parameter[j] = (0 + j * 0.4424283716980435 - pow(j, 2) * 0.06676211439554262 + pow(j, 3) * 0.0026358061791573453 - pow(j, 4) * 0.000029417130873311177 + pow(j, 5) * 1.0292852149593944e-7) * 0.001 #----------------------Read files------------------------------------------------------------------------------------------------------ OutputPath = "/media/MPI/ASCA/images/s160521/out/" cloudiness_value = [] ASCAtime = [] cloudmasks = [] # print(InputFilePath) for InputFile in sorted(glob.glob(InputFilePath + '/*.jpg')): #--------------------------------------------------------------------------------------------------------- #--------Get day and time------------ if debugger == True: print("Getting day and time") date_str = InputFile[len(InputFile) - 19:len(InputFile) - 19 + 12] if debugger == True: print("Date_Str: " + date_str) Year_str = date_str[0:2] Month_str = date_str[2:4] Day_str = date_str[4:6] Hour_str = date_str[6:8] Minute_str = date_str[8:10] Second_str = date_str[10:12] Year = int(date_str[0:2]) Month = int(date_str[2:4]) Day = int(date_str[4:6]) Hour = int(date_str[6:8]) Minute = int(date_str[8:10]) Second = int(date_str[10:12]) #------------Calculate SZA-------------------------------------------------------------------------------------------------------------- if debugger == True: print("Calculating SZA") tus = Location( 13.164, -59.433, 'UTC', 70, 'BCO' ) #This is the location of the Cloud camera used for calculating the Position of the sun in the picture times = pd.date_range(start=datetime.datetime(Year + 2000, Month, Day, Hour, Minute, Second), end=datetime.datetime(Year + 2000, Month, Day, Hour, Minute, Second), freq='10s') times_loc = times.tz_localize(tus.pytz) pos = pvlib.solarposition.get_solarposition(times_loc, tus.latitude, tus.longitude, method='nrel_numpy', pressure=101325, temperature=25) sza = float(pos.zenith[0]) if debugger: print("sza=" + str(sza)) if (84 < sza <= 85): #The program will only process images made at daylight time1 = clock() azimuth = float(pos.azimuth[0]) sza_orig = sza azi_orig = azimuth azimuth = azimuth + 190 #197 good # print(( str(sza) + ' '+Hour_str+':'+Minute_str)) if azimuth > 360: azimuth = azimuth - 360 #------------Open csv-File------------------------------------------------------------------------------------------------------------- if debugger == True: print("Open csv-File") if TXTFile == True: f = open( OutputPath + Year_str + Month_str + Day_str + '_' + Hour_str + Minute_str + Second_str + '_ASCA.csv', 'w') f.write( 'Seconds_since_1970, UTC_Time, SZA_in_degree, Azimuth_in_degree, Cloudiness_in_percent, Cloudiness_in_oktas' + '\n') TXTFile = False #---Read image and set some parameters------------------------------------------------------------------------------------------------- if debugger == True: print("Reading image and setting parameters") #------------rescale picture------------------------------------------- image = Image.open(InputFile) x_size_raw = image.size[0] y_size_raw = image.size[1] scale_factor = (set_scale_factor / 100.) NEW_SIZE = (x_size_raw * scale_factor, y_size_raw * scale_factor) image.thumbnail(NEW_SIZE, Image.ANTIALIAS) image = ImageOps.mirror(image) #Mirror picture x_size = image.size[0] y_size = image.size[1] x_mittel = x_size / 2 # Detect center of the true image y_mittel = y_size / 2 Radius = 900 #pixel # Set area for the true allsky image scale = x_size / 2592. #-------------convert image to an array and remove unnecessary part araund true allsky image----------------------------------------------------------------- if debugger == True: print("Drawing circle around image and removing the rest") r = Radius * scale y, x = np.ogrid[-y_mittel:y_size - y_mittel, -x_mittel:x_size - x_mittel] x = x + (15 * scale) #move centerpoint manually y = y - (40 * scale) mask = x**2 + y**2 <= r**2 #make a circular boolean array which is false in the area outside the true allsky image image_array = np.asarray( image, order='F' ) #converting the image to an array with array[x,y,color]; color: 0=red, 1,green, 2=blue image_array.setflags( write=True ) #making it able to work with that array and change it image_array[:, :, :][~mask] = [ 0, 0, 0 ] #using the mask created before on that new made array if Radius_synop == True: mask = x**2 + y**2 <= (765 * scale)**2 image_array[:, :, :][~mask] = [0, 0, 0] del x, y # #------------Calculate position of sun on picture--------------------------------------------------------------------------------------- if debugger == True: print("Calculating position of the sun on picture") sza = sza - 90 if sza < 0: sza = sza * (-1) AzimutWinkel = ((2 * math.pi) / 360) * (azimuth - 90) sza = ((2 * math.pi) / 360) * sza x_sol_cen = x_mittel - (15 * scale) y_sol_cen = y_mittel + (40 * scale) RadiusBild = r sza_dist = RadiusBild * math.cos(sza) x = x_sol_cen - sza_dist * math.cos(AzimutWinkel) y = y_sol_cen - sza_dist * math.sin(AzimutWinkel) ###-----------Draw circle around position of sun------------------------------------------------------------------------------------------- if debugger == True: print("Drawing circle around position of sun") x_sol_cen = int(x) y_sol_cen = int(y) Radius_sol = 300 * scale Radius_sol_center = 250 * scale y, x = np.ogrid[-y_sol_cen:y_size - y_sol_cen, -x_sol_cen:x_size - x_sol_cen] sol_mask = x**2 + y**2 <= Radius_sol**2 sol_mask_cen = x**2 + y**2 <= Radius_sol_center**2 sol_mask_cen1 = sol_mask_cen image_array[:, :, :][sol_mask_cen] = [0, 0, 0] # image_array[:,:,:][] ##-------Calculate Sky Index SI and Brightness Index BI------------Based on Letu et al. (2014)------------------------------------------------- if debugger == True: print("Calculating Sky Index SI and Brightness Index BI") image_array_f = image_array.astype(float) SI = ((image_array_f[:, :, 2]) - (image_array_f[:, :, 0])) / (((image_array_f[:, :, 2]) + (image_array_f[:, :, 0]))) where_are_NaNs = np.isnan(SI) SI[where_are_NaNs] = 1 mask_sol1 = SI < 0.1 Radius = 990 * scale sol_mask_double = x**2 + y**2 <= Radius**2 mask_sol1 = np.logical_and(mask_sol1, ~sol_mask_double) image_array[:, :, :][mask_sol1] = [255, 0, 0] ###-------------Include area around the sun---------------------------------------------------------------------------------------------------- if debugger == True: print("Including area around the sun") y, x = np.ogrid[-y_sol_cen:y_size - y_sol_cen, -x_sol_cen:x_size - x_sol_cen] sol_mask = x**2 + y**2 <= Radius_sol**2 sol_mask_cen = x**2 + y**2 <= Radius_sol_center**2 sol_mask_cen = np.logical_and(sol_mask_cen, sol_mask) Radius_sol = size * 100 * 2 sol_mask = x**2 + y**2 <= Radius_sol**2 mask2 = np.logical_and(~sol_mask_cen, sol_mask) image_array_c = copy.deepcopy( image_array ) #duplicating array: one for counting one for printing a colored image time3 = clock() for j in range(size): Radius_sol = j * 10 * scale sol_mask = (x * x) + (y * y) <= Radius_sol * Radius_sol mask2 = np.logical_and(~sol_mask_cen, sol_mask) sol_mask_cen = np.logical_or(sol_mask, sol_mask_cen) mask3 = SI < parameter[j] mask3 = np.logical_and(mask2, mask3) image_array_c[mask3] = [255, 0, 0] image_array[mask3] = [255, 300 - 3 * j, 0] time4 = clock() # print 'Schleifenzeit:', time4-time3 ##---------Count red pixel(clouds) and blue-green pixel(sky)------------------------------------------------------------------------------------------- if debugger == True: print("Counting red pixel for sky and blue for clouds") c_mask = np.logical_and(~sol_mask_cen1, mask) c_array = (image_array_c[:, :, 0] + image_array_c[:, :, 1] + image_array_c[:, :, 2]) #array just for the counting Count1 = np.shape(np.where(c_array == 255))[1] Count2 = np.shape(np.where(c_mask == True))[1] CloudinessPercent = (100 / float(Count2) * float(Count1)) CloudinessSynop = int(round(8 * (float(Count1) / float(Count2)))) image = Image.fromarray(image_array.astype(np.uint8)) #----------Mirror Image----------------------------- image = ImageOps.mirror(image) #Mirror Image back #---------Add Text----------------------------------- if debugger == True: print("Adding text") sza = "{:5.1f}".format(sza_orig) azimuth = "{:5.1f}".format(azi_orig) CloudinessPercent = "{:5.1f}".format(CloudinessPercent) # draw = ImageDraw.Draw(image) # draw.text((20*scale, 20*scale),"BCO All-Sky Camera",(255,255,255),font=font) # draw.text((20*scale, 200*scale),Hour_str+":"+Minute_str+' UTC',(255,255,255),font=font) # # draw.text((20*scale, 1700*scale),"SZA = "+str(sza)+u'\u00B0',(255,255,255),font=font) # draw.text((20*scale, 1820*scale),"Azimuth = "+str(azimuth)+u'\u00B0',(255,255,255),font=font) # # draw.text((1940*scale, 1700*scale),"Cloudiness: ",(255,255,255),font=font) # draw.text((1930*scale, 1820*scale),str(CloudinessPercent)+'% '+ str(CloudinessSynop)+'/8',(255,255,255),font=font) # # draw.text((1990*scale, 20*scale),Day_str+'.'+Month_str+'.20'+Year_str,(255,255,255),font=font) #-------------Save values to csv-File--------------------------------------- # if debugger == True: # print "Saving values to csv-File" # EpochTime=(datetime.datetime(2000+Year,Month,Day,Hour,Minute,Second) - datetime.datetime(1970,1,1)).total_seconds() # f.write(str(EpochTime)+', '+Hour_str+':'+Minute_str+', '+str(sza)+', '+str(azimuth)+', '+str(CloudinessPercent)+', '+str(CloudinessSynop)+'\n') #-------------Save picture-------------------------------------------------- if Save_image == True: if debugger == True: print("saving picture") image = convert(InputFile, image, OutputPath) image.save(OutputPath + Year_str + Month_str + Day_str + '_' + Hour_str + Minute_str + Second_str + '_ASCA.jpg') #image.show() time2 = clock() time = time2 - time1 cloudiness_value.append(CloudinessPercent) ASCAtime.append((datetime.datetime(Year + 2000, Month, Day, Hour, Minute, Second))) cloudmask = [c_array == 255] cloudmask = cloudmask[0] * 1 cloudmask[np.where(c_mask == False)] = -1 clodmask = np.fliplr(cloudmask) cloudmasks.append(cloudmask) # print "Berechnungszeit: ", time return cloudiness_value, ASCAtime, cloudmasks, set_scale_factor
async def imirror(event): # sourcery no-metrics "imgae refelection fun." reply = await event.get_reply_message() mediatype = media_type(reply) if not reply or not mediatype or mediatype not in ["Photo", "Sticker"]: return await edit_delete( event, "__Reply to photo or sticker to make mirror.__") catevent = await event.edit("__Reflecting the image....__") args = event.pattern_match.group(1) if args: filename = "catuserbot.webp" f_format = "webp" else: filename = "catuserbot.jpg" f_format = "jpeg" try: imag = await _cattools.media_to_pic(catevent, reply, noedits=True) if imag[1] is None: return await edit_delete( imag[0], "__Unable to extract image from the replied message.__") image = Image.open(imag[1]) except Exception as e: return await edit_delete( catevent, f"**Error in identifying image:**\n__{str(e)}__") flag = event.pattern_match.group(3) or "r" w, h = image.size if w % 2 != 0 and flag in ["r", "l"] or h % 2 != 0 and flag in ["u", "b"]: image = image.resize((w + 1, h + 1)) h, w = image.size if flag == "l": left = 0 upper = 0 right = w // 2 lower = h nw = right nh = left elif flag == "r": left = w // 2 upper = 0 right = w lower = h nw = upper nh = upper elif flag == "u": left = 0 upper = 0 right = w lower = h // 2 nw = left nh = lower elif flag == "b": left = 0 upper = h // 2 right = w lower = h nw = left nh = left temp = image.crop((left, upper, right, lower)) temp = ImageOps.mirror(temp) if flag in ["l", "r"] else ImageOps.flip(temp) image.paste(temp, (nw, nh)) img = BytesIO() img.name = filename image.save(img, f_format) img.seek(0) await event.client.send_file(event.chat_id, img, reply_to=reply) await catevent.delete()
def preprocess(observe): ret = Image.fromarray(observe) ret = ImageOps.mirror(ret.rotate(270)).convert('L').resize( (RESIZE, RESIZE)) return np.asarray(ret)
stage = stages.Stage1() # 初期描画 root = tk.Tk() root.title(stage.name) root.geometry(f'{WINDOW_WIDTH}x{WINDOW_HEIGHT}+0+0') cv = tk.Canvas(root, width=WINDOW_WIDTH, height=WINDOW_HEIGHT, bg='white') cv.pack() cv.focus_set() # 画像の読み込み # キャラクター obake_img = Image.open('./img/obake.png') obake_img = obake_img.resize((IMG_SIZE, IMG_SIZE)) obake_flip_img = ImageOps.flip(obake_img) # 上下反転 obake_mirror_img = ImageOps.mirror(obake_img) # 左右反転(右向き) obake_fm_img = ImageOps.mirror(obake_flip_img) # 上下左右反転 obake_tkimg = ImageTk.PhotoImage(obake_img) obake_flip_tkimg = ImageTk.PhotoImage(obake_flip_img) obake_mirror_tkimg = ImageTk.PhotoImage(obake_mirror_img) obake_fm_tkimg = ImageTk.PhotoImage(obake_fm_img) # 重力ブロック udarrow_img = Image.open('./img/updownarrow.png') udarrow_img = udarrow_img.resize((BLOCK_SIZE, BLOCK_SIZE)) udarrow2_img = udarrow_img.resize((BLOCK_SIZE*2, BLOCK_SIZE*2)) udarrow_tkimg = ImageTk.PhotoImage(udarrow_img) udarrow2_tkimg = ImageTk.PhotoImage(udarrow2_img) # 看板 triple_size = (BLOCK_SIZE*3, BLOCK_SIZE*3) dsc_J_img = Image.open(f'./img/dsc_J.png').resize(triple_size) dsc_K_img = Image.open(f'./img/dsc_K.png').resize(triple_size)
def conv_image_to_module(name, scale_factor): module = header % {"name": name.upper()} front_image = Image.open("%s_front.png" % name).transpose(Image.FLIP_TOP_BOTTOM) print("Reading image from \"%s_front.png\"" % name) front_image_red, front_image_green, front_image_blue, front_image_alpha = front_image.split() # Soldermask needs to be inverted front_image_red = ImageOps.invert(front_image_red) front_image_red = Image.composite(front_image_red, front_image_alpha, front_image_alpha) front_image_red = front_image_red.point(lambda i: 0 if i < 127 else 1) red_array = np.array(front_image_red) bmp_red = potrace.Bitmap(red_array) path_red = bmp_red.trace(alphamax = 0.0, opttolerance = 50) # Soldermask needs to be inverted front_image_green = ImageOps.invert(front_image_green) front_image_green = Image.composite(front_image_green, front_image_alpha, front_image_alpha) front_image_green = front_image_green.point(lambda i: 0 if i < 127 else 1) green_array = np.array(front_image_green) bmp_green = potrace.Bitmap(green_array) path_green = bmp_green.trace(alphamax = 0.0, opttolerance = 50) front_image_blue = front_image_blue.point(lambda i: 0 if i < 127 else 1) blue_array = np.array(front_image_blue) bmp_blue = potrace.Bitmap(blue_array) path_blue = bmp_blue.trace(alphamax = 0.0, opttolerance = 50) front_image_alpha = front_image_alpha.point(lambda i: 0 if i < 127 else 1) front_image_alpha_array = np.array(front_image_alpha) bmp_alpha = potrace.Bitmap(front_image_alpha_array) path_alpha = bmp_alpha.trace(alphamax = 0.0, opttolerance = 50) w, h = front_image.size # print("Generating Outline layer from front alpha channel") # module += render_path_to_layer(path_alpha, "line", "20", scale_factor) print("Generating tKeepout layer from front red channel") module += render_path_to_layer(path_red, "poly", "39", scale_factor) print("Generating tStop layer from front green channel") module += render_path_to_layer(path_green, "poly", "29", scale_factor) print("Generating tPlace layer from front blue channel") module += render_path_to_layer(path_blue, "poly", "21", scale_factor) try: back_image = Image.open("%s_back.png" % name).transpose(Image.FLIP_TOP_BOTTOM) back_image = ImageOps.mirror(back_image) print("Reading image from \"%s_back.png\"" % name) back_image_red, back_image_green, back_image_blue, back_image_alpha = back_image.split() back_image_red = back_image_red.point(lambda i: 0 if i < 127 else 1) red_array = np.array(back_image_red) bmp_red = potrace.Bitmap(red_array) path_red = bmp_red.trace(alphamax = 0.0, opttolerance = 50) # Soldermask needs to be inverted back_image_green = ImageOps.invert(back_image_green) back_image_green = back_image_green.point(lambda i: 0 if i < 127 else 1) green_array = np.array(back_image_green) bmp_green = potrace.Bitmap(green_array) path_green = bmp_green.trace(alphamax = 0.0, opttolerance = 50) back_image_blue = back_image_blue.point(lambda i: 0 if i < 127 else 1) blue_array = np.array(back_image_blue) bmp_blue = potrace.Bitmap(blue_array) path_blue = bmp_blue.trace(alphamax = 0.0, opttolerance = 50) print("Generating bKeepout layer from back red channel") module += render_path_to_layer(path_red, "poly", "40", scale_factor) print("Generating bStop layer from back green channel") module += render_path_to_layer(path_green, "poly", "30", scale_factor) print("Generating bPlace layer from back blue channel") module += render_path_to_layer(path_blue, "poly", "22", scale_factor) except IOError: pass module += footer % {"name": name.upper()} return module, (w * 25.4 / scale_factor, h * 25.4 / scale_factor)
def detect_birds(model, input_folder, output_folder_crop, generate_masks=False, output_folder_mask="mask_dataset"): kernel = np.ones((25, 25), 'uint8') for data_folder in list( os.listdir(input_folder)): # Iterate over train, val and test non_cropped = 0 non_cropped_names = [] num_imgs = 0 directory = input_folder + '/' + data_folder print("\nDetecting birds on :", data_folder) for folder in list( os.listdir(directory)): # Iterate over classes of birds size = len(list(os.listdir(directory + '/' + folder))) num_imgs += size os.makedirs(output_folder_crop, exist_ok=True) os.makedirs(output_folder_crop + '/' + data_folder + '/' + folder, exist_ok=True) if generate_masks: os.makedirs(output_folder_mask, exist_ok=True) os.makedirs(output_folder_mask + '/' + data_folder + '/' + folder, exist_ok=True) img_paths = [] img_detections = [] # Reformat weird images for file in os.listdir(directory + '/' + folder): if '.jpg' not in file: print(file) continue i = plt.imread(directory + '/' + folder + '/' + file) if len(i.shape) == 2 or i.shape[2] != 3: i = Image.fromarray(i) i = i.convert('RGB') i.save(directory + '/' + folder + '/' + file) del i # Get image paths and detections : not the most efficient way, but it avoids defining a proper detectron2-specific Dataloader for img_path in list(os.listdir(directory + '/' + folder)): if '.jpg' not in img_path: print(img_path) continue img = cv2.imread(directory + '/' + folder + '/' + img_path) with torch.no_grad(): detections = model(img)["instances"] img_paths.append(directory + '/' + folder + '/' + img_path) img_detections.append(detections) # Save cropped images for (path, detections) in (zip(img_paths, img_detections)): img = np.array(Image.open(path)) # Bounding boxes and labels of detections if len(detections.scores) > 0: # Get the most probable bird prediction bounding box index_birds = np.where(detections.pred_classes.cpu().numpy( ) == 14)[0] # 14 is the default class number for bird if len(index_birds) == 0: # Flip the image if we are not able to detect the bird non_cropped_names.append(path) non_cropped += 1 path = path.split("/")[-1] plt.imsave(output_folder_crop + '/' + data_folder + '/' + folder + '/' + path, np.array( ImageOps.mirror(Image.fromarray(img))), dpi=1000) plt.close() continue bird = int( torch.max(detections.scores[index_birds], 0)[1].cpu().numpy()) [ x1, y1, x2, y2 ] = detections.pred_boxes[index_birds][bird].tensor[0].cpu( ).numpy() mask = detections.pred_masks.cpu().numpy().astype( np.uint8).squeeze() count = 1 invalid_mask = False # If we are able to detect the bird, enlarge the bounding box and generate a new image # x1, y1 = np.maximum(0,int(x1)-20), np.maximum(0,int(y1)-20) # x2, y2 = np.minimum(x2+40,img.shape[1]), np.minimum(y2+40,img.shape[0]) # generate mask if generate_masks: if len(mask.shape) > 2: invalid_mask = True else: imgcv = cv2.imread(path) dilate_img = cv2.dilate(mask, kernel, iterations=1) masked_img = cv2.bitwise_and(imgcv, imgcv, mask=dilate_img) img = img[int(np.ceil(y1)):int(y2), int(np.ceil(x1)):int(x2), :] # crop the masked image if not invalid_mask: masked_img = masked_img[int(np.ceil(y1)):int(y2), int(np.ceil(x1)):int(x2), :] # Save generated image with detections path = path.split("/")[-1] print(output_folder_crop + '/' + data_folder + '/' + folder + '/' + path) plt.imsave(output_folder_crop + '/' + data_folder + '/' + folder + '/crop' + path, img, dpi=1000) if generate_masks: if not invalid_mask: masked_img = cv2.cvtColor(masked_img, cv2.COLOR_BGR2RGB) plt.imsave(output_folder_mask + '/' + data_folder + '/' + folder + '/' + path, masked_img, dpi=1000) plt.close() else: # Flip the image if we are not able to detect the bird non_cropped_names.append(path) non_cropped += 1 path = path.split("/")[-1] # Flip the image if we are not able to detect it plt.imsave(output_folder_crop + '/' + data_folder + '/' + folder + '/crop' + path, np.array(ImageOps.mirror(Image.fromarray(img))), dpi=1000) plt.close() print("\t{}% of {} images non cropped".format( np.round(100 * non_cropped / num_imgs, 2), data_folder)) return (non_cropped_names)
async def KZD(message, type): S = 'sticker' A = message N = await A.get_reply_message() Q, J = await CM(N) if not Q or not N: await A.edit('<b>Реплай на стикер или фото!</b>') return O = 'KZD.' + J P = U.get_args_raw(A) if P: if P in [_A[:A] for A in range(1, len(_A) + 1)]: O = 'KZD.png' J = _C if P in [S[:A] for A in range(1, len(S) + 1)]: O = 'KZD.webp' J = 'webp' R = ist() await A.edit('<b>Извиняюсь...</b>') await A.client.download_media(Q, R) E = Image.open(R) B, C = E.size if B % 2 != 0 and type in [1, 2] or C % 2 != 0 and type in [3, 4]: E = E.resize((B + 1, C + 1)) C, B = E.size if type == 1: D = 0 F = 0 G = B // 2 H = C K = G L = D if type == 2: D = B // 2 F = 0 G = B H = C K = F L = F if type == 3: D = 0 F = 0 G = B H = C // 2 K = D L = H if type == 4: D = 0 F = C // 2 G = B H = C K = D L = D I = E.crop((D, F, G, H)) if type in [1, 2]: I = IO.mirror(I) else: I = IO.flip(I) E.paste(I, (K, L)) M = ist() M.name = O E.save(M, J) M.seek(0) await A.client.send_file(A.to_id, M, reply_to=N) await A.delete()
def reflect_y_axis(im): return ImageOps.mirror(im).rotate(180,expand=True)
if count == max_count: break print file, round(total_count2 * 100.0 / total_count, 2) total_count2 += 1 row = fish_label(label) lbl_text = str(row[0]) + "," + str(row[1]) + "," + str( row[2]) + "," + str(row[3]) + "," + str(row[4]) + "," + str( row[5]) + "," + str(row[6]) + "," + str(row[7]) name, ext = file.split(".") for t in xrange(8): img = Image.open(path + file, 'r') # print t if t == 1: img = ImageOps.mirror(img) if t == 2: img = ImageOps.flip(img) if t == 3: img = ImageOps.mirror(img) img = ImageOps.flip(img) if t == 4: img = img.rotate(90) if t == 5: img = img.rotate(90) img = ImageOps.mirror(img) if t == 6: img = img.rotate(270) if t == 7: img = img.rotate(270) img = ImageOps.mirror(img)
def mirror(self, section): src = self._get_option(section, 'src') dst = self._get_option(section, 'dst', src) self.buffers[dst] = ImageOps.mirror(self.buffers[src])
ctx.dump(path) image = Image.open(path) image.filter(ImageFilter.GaussianBlur(blur_radius)).save(path) print(' end', flush=True) #------------------------------------------------------------- # generate bottom mask image #------------------------------------------------------------- ctx.clear() print('\n### Top Mask Image ###') print('loading... ', end='', flush=True) mask = load_layer(prefix + '.GBS') print(' end', flush=True) print('drawing... ', end='', flush=True) ctx.render_layer(mask, settings=mask_settings, bgsettings=maskbg_settings) print(' end', flush=True) print('dumping... ', end='', flush=True) ctx.dump('outputs/pcb-bottom-mask.png') print(' end', flush=True) #print('flipping... ', end='', flush=True) base_image = Image.open('outputs/pcb-bottom-base.png') hmap_image = Image.open('outputs/pcb-bottom-hmap.png') mask_image = Image.open('outputs/pcb-bottom-mask.png') ImageOps.mirror(base_image).save('outputs/pcb-bottom-base.png') ImageOps.mirror(hmap_image).save('outputs/pcb-bottom-hmap.png') ImageOps.mirror(mask_image).save('outputs/pcb-bottom-mask.png')
def export_image( input, output, timeout=20, palette="white", resolution=150, layers=None, command=None, mirror=False, showgui=False, ): """ Exporting eagle .sch or .brd file into image file. If export is blocked somehow (e.g. popup window is displayed) then after timeout operation is canceled with exception. Problem can be investigated by setting 'showgui' flag. Exporting generates an image file. Only PNG format is supported :param input: eagle .sch or .brd file name :param output: image file name (e.g. 'eagle.png') :param palette: background color [None,black,white,colored] :param resolution: image resolution in dpi (50..2400) :param timeout: operation is canceled after this timeout (sec) :param showgui: eagle GUI is displayed :param layers: list, layers to be displayed ['top','pads'] :param command: string, direct eagle command :param mirror: Bool :rtype: None """ input = norm_path(input) output = norm_path(output) if not output.endswith(".png"): raise ValueError("use .png extension!") if palette: palette = palette.lower() if palette == "none": palette = None cmds = [] if palette is not None: cmds += ["SET PALETTE {palette}".format(palette=palette)] if layers is not None: cmds += ["DISPLAY NONE " + " ".join(layers)] if command is not None: cmds += [command] with tempfile.TemporaryDirectory() as temp_dir: if mirror: fout = join(temp_dir, "out.png") else: fout = output commands = export_command(output=fout, output_type="image", commands=cmds, resolution=resolution) command_eagle(input=input, timeout=timeout, commands=commands, showgui=showgui) if mirror: im = Image.open(fout) # save dpi info info = im.info im = ImageOps.mirror(im) im.save(output, **info)
def imageBorder(img, thickness, edgeFill="#ffffff00"): """ Add a border of thickness pixels around the image :param img: the image to add a border to can be pil image, numpy array, or whatever :param thickness: the border thickness in pixels. Can be: int - border all the way around (w_border,h_border) - add border this big to each side (x,y,x2,y2) - add border this big to each side :param edgeFill: defines how to extend. It can be: mirror - reflect the pixels leading up to the border repeat - repeat the image over again (useful with repeating textures) clamp - streak last pixels out to edge [background color] - simply fill with the given color TODO: combine into extendImageCanvas function """ if not isinstance(thickness, (tuple, list)): thickness = (thickness, thickness, thickness, thickness) elif len(thickness) == 2: thickness = (thickness[0], thickness[1], thickness[0], thickness[1]) thickness = [int(t) for t in thickness] img = imageRepr.pilImage(img) newSize = (int(img.size[0] + thickness[0] + thickness[2]), int(img.size[1] + thickness[1] + thickness[3])) if edgeFill == 'mirror': newImage = Image.new(img.mode, newSize) # top fill = ImageOps.flip(img.crop((0, 0, img.width, thickness[1]))) newImage.paste(fill, (thickness[1], 0)) # bottom fill = ImageOps.flip( img.crop((0, img.height - thickness[2], img.width, img.height))) newImage.paste(fill, (thickness[2], img.height + thickness[2])) # left fill = ImageOps.mirror(img.crop((0, 0, thickness[0], img.height))) newImage.paste(fill, (0, thickness[0])) # right fill = ImageOps.mirror( img.crop((img.width - thickness[3], 0, img.width, img.height))) newImage.paste(fill, (img.width + thickness[3], thickness[3])) # top-left corner #fill=ImageOps.mirror(ImageOps.flip(img.crop((0,0,thickness,thickness)))) #newImage.paste(fill,(0,0)) # top-right corner #fill=ImageOps.mirror(ImageOps.flip(img.crop((img.width-thickness,0,img.width,thickness)))) #newImage.paste(fill,(img.width+thickness,0)) # bottom-left corner #fill=ImageOps.mirror(ImageOps.flip(img.crop((0,img.height-thickness,thickness,img.height)))) #newImage.paste(fill,(0,img.height+thickness)) # bottom-right corner #fill=ImageOps.mirror(ImageOps.flip(img.crop((img.width-thickness,img.height-thickness,img.width,img.height)))) #newImage.paste(fill,(img.width+thickness,img.height+thickness)) elif edgeFill == 'repeat': newImage = Image.new(img.mode, newSize) # top fill = img.crop((0, 0, img.width, thickness[1])) newImage.paste(fill, (thickness[1], img.height + thickness[1])) # bottom fill = img.crop((0, img.height - thickness[2], img.width, img.height)) newImage.paste(fill, (thickness[2], 0)) # left fill = img.crop((0, 0, thickness[0], img.height)) newImage.paste(fill, (img.width + thickness[0], thickness[0])) # right fill = img.crop((img.width - thickness[3], 0, img.width, img.height)) newImage.paste(fill, (0, thickness[3])) # top-left corner fill = img.crop((0, 0, thickness, thickness)) newImage.paste(fill, (img.width + thickness, img.height + thickness)) # top-right corner fill = img.crop((img.width - thickness, 0, img.width, thickness)) newImage.paste(fill, (0, img.height + thickness)) # bottom-left corner fill = img.crop((0, img.height - thickness, thickness, img.height)) newImage.paste(fill, (img.width + thickness, 0)) # bottom-right corner fill = img.crop((img.width - thickness, img.height - thickness, img.width, img.height)) newImage.paste(fill, (0, 0)) elif edgeFill == 'clamp': newImage = Image.new(img.mode, newSize) # top fill = img.crop((0, 0, img.width, 1)).resize((img.width, thickness[1]), resample=Image.NEAREST) newImage.paste(fill, (thickness[1], 0)) # bottom fill = img.crop((0, img.height - 1, img.width, img.height)).resize( (img.width, thickness[2]), resample=Image.NEAREST) newImage.paste(fill, (thickness[2], img.height + thickness[2])) # left fill = img.crop((0, 0, 1, img.height)).resize( (thickness[0], img.height), resample=Image.NEAREST) newImage.paste(fill, (0, thickness[0])) # right fill = img.crop((img.width - 1, 0, img.width, img.height)).resize( (thickness[3], img.height), resample=Image.NEAREST) newImage.paste(fill, (img.width + thickness[3], thickness[3])) # TODO: corners # top-left corner fill = img.crop((0, 0, 1, 1)).resize((thickness, thickness), resample=Image.NEAREST) newImage.paste(fill, (0, 0)) # top-right corner fill = img.crop((img.width - 1, 0, img.width, 1)).resize( (thickness, thickness), resample=Image.NEAREST) newImage.paste(fill, (img.width + thickness, 0)) # bottom-left corner fill = img.crop((0, img.height - 1, 1, img.height)).resize( (thickness, thickness), resample=Image.NEAREST) newImage.paste(fill, (0, img.height + thickness)) # bottom-right corner fill = img.crop( (img.width - 1, img.height - 1, img.width, img.height)).resize( (thickness, thickness), resample=Image.NEAREST) newImage.paste(fill, (img.width + thickness, img.height + thickness)) else: newImage = Image.new(img.mode, newSize, edgeFill) # splat the original image in the middle if True: if newImage.mode.endswith('A'): newImage.alpha_composite(img, dest=(thickness[0], thickness[1])) else: newImage.paste(img, (thickness[0], thickness[1])) return newImage
def test_sanity(self): ImageOps.autocontrast(hopper("L")) ImageOps.autocontrast(hopper("RGB")) ImageOps.autocontrast(hopper("L"), cutoff=10) ImageOps.autocontrast(hopper("L"), ignore=[0, 255]) ImageOps.autocontrast_preserve(hopper("L")) ImageOps.autocontrast_preserve(hopper("RGB")) ImageOps.autocontrast_preserve(hopper("L"), cutoff=10) ImageOps.autocontrast_preserve(hopper("L"), ignore=[0, 255]) ImageOps.colorize(hopper("L"), (0, 0, 0), (255, 255, 255)) ImageOps.colorize(hopper("L"), "black", "white") ImageOps.crop(hopper("L"), 1) ImageOps.crop(hopper("RGB"), 1) ImageOps.deform(hopper("L"), self.deformer) ImageOps.deform(hopper("RGB"), self.deformer) ImageOps.equalize(hopper("L")) ImageOps.equalize(hopper("RGB")) ImageOps.expand(hopper("L"), 1) ImageOps.expand(hopper("RGB"), 1) ImageOps.expand(hopper("L"), 2, "blue") ImageOps.expand(hopper("RGB"), 2, "blue") ImageOps.fit(hopper("L"), (128, 128)) ImageOps.fit(hopper("RGB"), (128, 128)) ImageOps.flip(hopper("L")) ImageOps.flip(hopper("RGB")) ImageOps.grayscale(hopper("L")) ImageOps.grayscale(hopper("RGB")) ImageOps.invert(hopper("L")) ImageOps.invert(hopper("RGB")) ImageOps.mirror(hopper("L")) ImageOps.mirror(hopper("RGB")) ImageOps.posterize(hopper("L"), 4) ImageOps.posterize(hopper("RGB"), 4) ImageOps.solarize(hopper("L")) ImageOps.solarize(hopper("RGB"))