def wand1(): """This is Python Wand example 1""" the_time = t.asctime() print "Importing image ", IFILE img_1 = Image(filename=IFILE) print "Cropping and resizing the image" img_1.crop(300, 0, width=300, height=282) img_1.resize(width=600, height=564) print "Creating a drawing and overlaying on it" draw = Drawing() draw.circle((100, 100), (120, 120)) draw.rectangle(left=img_1.width-300, top=img_1.height-45, width=230, height=40, radius=5) draw.font_size = 17 draw.fill_color = Color('white') draw.text_color = Color('white') draw.text(img_1.width-290, img_1.height-20, the_time) draw(img_1) print "Displaying, close the XTERM when done" display(img_1)
def compose_image_slide(self, image_path=None, text=None, slide_id=1): image_display_size = (300, 190) key = '%s-%s-%03d' % (self.emission.uuid, self.content_object.uuid, slide_id) path = os.path.join(SLIDE_BASE_DIR, key + '.{}'.format(IMAGE_OUTPUT_FORMAT)) url = SLIDE_BASE_URL + key + '.{}'.format(IMAGE_OUTPUT_FORMAT) overlay_image = Image(filename=image_path) with Drawing() as draw: size = overlay_image.size if size[0] > size[1]: orientation = 'landscape' scale = float(image_display_size[1]) / float(size[1]) else: orientation = 'portrait' scale = float(image_display_size[1]) / float(size[0]) overlay_image.resize(int(size[0] * scale), int(size[1] * scale)) #size = overlay_image.size width = 190 height = 190 overlay_image.crop(10, 0, width=width, height=height) draw.composite('over', left=int(width / 2) - 20, top=10, width=width, height=height, image=overlay_image) # text settings draw.font = SLIDE_BASE_FONT draw.font_size = 14 draw.text_interline_spacing = 8 draw.fill_color = Color('white') draw.text_antialias = True # draw text if text: draw.text(220, 10, text) # compose image with Image(filename=SLIDE_BASE_IMAGE) as image: draw(image) if IMAGE_OUTPUT_FORMAT == 'jpg': image.compression_quality = 62 image.format = 'jpeg' image.save(filename=path) image.save(filename=os.path.join(SLIDE_BASE_DIR, 'debug-{}.{}'.format(slide_id, IMAGE_OUTPUT_FORMAT))) try: overlay_image.close() except Exception as e: # TODO: use narrowed exception(s) log.warning('unable to close magick/wand overlay image - {}'.format(e)) return url
def convert_image(pngfile, pf, outdir=".", resize=1000, format="jpeg", rotate=0, rows=':', cols=':', labelrows=None, labelcols=None): resizefile = op.join(outdir, pf + ".resize.jpg") mainfile = op.join(outdir, pf + ".main.jpg") labelfile = op.join(outdir, pf + ".label.jpg") img = Image(filename=pngfile) exif = dict((k, v) for k, v in img.metadata.items() if k.startswith('exif:')) # Rotation, slicing and cropping of main image if rotate: img.rotate(rotate) if resize: w, h = img.size if min(w, h) > resize: if w < h: nw, nh = resize, resize * h / w else: nw, nh = resize * w / h, resize img.resize(nw, nh) logging.debug("Image `{0}` resized from {1}px:{2}px to {3}px:{4}px".\ format(pngfile, w, h, nw, nh)) img.format = format img.save(filename=resizefile) rimg = img.clone() if rows != ':' or cols != ':': w, h = img.size ra, rb = slice(rows, h) ca, cb = slice(cols, w) # left, top, right, bottom logging.debug("Crop image to {0}:{1} {2}:{3}".format(ra, rb, ca, cb)) img.crop(ca, ra, cb, rb) img.format = format img.save(filename=mainfile) else: mainfile = resizefile # Extract text labels from image if labelrows or labelcols: w, h = rimg.size if labelrows and not labelcols: labelcols = ':' if labelcols and not labelrows: labelrows = ':' ra, rb = slice(labelrows, h) ca, cb = slice(labelcols, w) logging.debug("Extract label from {0}:{1} {2}:{3}".format(ra, rb, ca, cb)) rimg.crop(ca, ra, cb, rb) rimg.format = format rimg.save(filename=labelfile) else: labelfile = None return resizefile, mainfile, labelfile, exif
def animate_slice(sliceviewer, name, start, end, filename, num_frames=10, font_size=24): """Generate an animated gif of a 2D slice moving through a third dimension. Args: sliceviewer (SliceViewer): A sliceviewer instance. name (str): The name of the third dimension to use. start (float): The starting value of the third dimension. end (float): The end value of the third dimension. filename (str): The file to save the gif to. Kwargs: num_frames (int): The number of frames the gif should contain. font_size: (int): The size of the caption. Example: ws = CreateMDWorkspace(3, Extents=[-10,10,-10,10,-10,10], Names=["X","Y","Z"], Units=["u","u","u"]) FakeMDEventData(ws, PeakParams=[10000,0,0,0,1]) sv = plotSlice(ws) #Resize and configure the slice viewer how you want the output to look sv.setNormalization(1) # We need to normalize by volume in this case, or the data won't show up #This will create a gif iterating from Z = -1 to Z = 1 animate_slice(sv, "Z", -1, 1, "output.gif") """ #Generate all the individual frames images = [] for slice_point in numpy.linspace(start, end, num_frames): sliceviewer.setSlicePoint(name, slice_point) sliceviewer.refreshRebin() qimg = sliceviewer.getImage().toImage() data = QByteArray() buf = QBuffer(data) qimg.save(buf, "PNG") image = Image(blob=str(data)) captionstrip_size = font_size + 10 #To add whitespace to the top, we add a vertical border, #then crop out the bottom border image.border(Color("#fff"), 0, captionstrip_size) image.crop(0, 0, image.width, image.height - captionstrip_size) #Write the caption into the whitespace draw = Drawing() draw.font_size = font_size draw.text(5, font_size,"%s = %g" % (name,slice_point)) draw(image) images.append(image) #Create a new image with the right dimensions animation = Image(width=images[0].width, height=images[0].height) #Copy in the frames from all the generated images for image in images: animation.sequence.append(image.sequence[0]) #Drop the initial blank frame del animation.sequence[0] #Write the animation to disk animation.save(filename=filename)
def renderAnimation(animationName, numFrames): print("Rendering animation: " + animationName) dirToFramesMapping = dict() animationDirectory = workingDirectory + animationName + "/" for key, value in directions.items(): directory = animationDirectory + value + "/" frames = [] for i in range(0, numFrames): frameBuffer = Image(filename=(directory + animationName + "_" + str(i + 1) + ".png")); if(frameBuffer.width > frameWidth): frameBuffer.crop(int((frameBuffer.width - frameWidth)/2), 0, width=frameWidth, height=frameBuffer.height) if(frameBuffer.height > frameHeight): frameBuffer.crop(0, int((frameBuffer.height - frameHeight)/2), frameBuffer.width, height=frameHeight) newBuffer = Image(width=frameWidth, height=frameHeight) newBuffer.composite(frameBuffer, int((newBuffer.width - frameBuffer.width) / 2), int((newBuffer.height - frameBuffer.height) / 2)) frameBuffer = newBuffer frames.append(frameBuffer) dirToFramesMapping[key] = frames directionAnimations = dict() for key, value in dirToFramesMapping.items(): directionAnimationBuffer = Image(width=frameWidth * numFrames, height=frameHeight) for i in range(0, len(value)): frameBuffer = value[i] directionAnimationBuffer.composite(frameBuffer, i * frameWidth, 0) directionAnimations[key] = directionAnimationBuffer animation = Image(width=frameWidth * numFrames, height=frameHeight * len(directions)) animation.composite(directionAnimations["n"], 0, 0) animation.composite(directionAnimations["ne"], 0, frameHeight) animation.composite(directionAnimations["e"], 0, frameHeight * 2) animation.composite(directionAnimations["se"], 0, frameHeight * 3) animation.composite(directionAnimations["s"], 0, frameHeight * 4) animation.composite(directionAnimations["sw"], 0, frameHeight * 5) animation.composite(directionAnimations["w"], 0, frameHeight * 6) animation.composite(directionAnimations["nw"], 0, frameHeight * 7) animation.save(filename=animationDirectory + animationName + ".png")
def magick_crop(self, image_url=None, dataX=0, dataY=0, dataWidth=0, dataHeight=0, dataRotate=0, dataScaleX=1, dataScaleY=1, **kw): if 'ir.attachment' in image_url: # binary -> decode -> wand.image -> imagemagick -> make_blob() -> encode -> binary img_attachment = request.env['ir.attachment'].browse(int(image_url.split('/')[4].split('_')[0])) wand_img = Image(blob=getattr(img_attachment, 'datas').decode('base64')) try: wand_img.crop(int(dataX), int(dataY), width=int(dataWidth), height=int(dataHeight)) if dataScaleX and dataScaleY: wand_img.resize(int(wand_img.width * float(dataScaleX)), int(wand_img.height * float(dataScaleY))) if dataRotate: wand_img.rotate(int(dataRotate)) img_attachment.write({ 'datas': wand_img.make_blob().encode('base64') }) except Exception as e: return ': '.join(e) return 'Magic Crop Completed!' else: return 'Please using attachment as image!'
def open_image(path, colors, width = 60, crop = None, gauge = [40,40]) : # Find height ratio height_ratio = gauge[1] / float(gauge[0]) # Open image, resize and posterize with open(path) as fp : # Open image image = Image(file=fp) # Crop if crop != None : image.crop(crop['x'], crop['y'], crop['w'] + crop['x'], crop['h'] + crop['y']) # Resize to width and height ratio resize(image, width, height_ratio) # Get data data = get_data(PImage.open(StringIO.StringIO(image.make_blob('ppm')))) # Posterize image to fewer colors return posterize(data, colors)
def renderAnimation(animationName): print("Rendering animation: " + animationName) dirToFramesMapping = dict() animationDirectory = workingDirectory + animationName + "/" for key, value in directions.items(): frameBuffer = Image(filename=(animationDirectory + animationName + "_" + value + ".png")) if frameBuffer.width > frameWidth: frameBuffer.crop(int((frameBuffer.width - frameWidth) / 2), 0, width=frameWidth, height=frameBuffer.height) if frameBuffer.height > frameHeight: frameBuffer.crop(0, int((frameBuffer.height - frameHeight) / 2), frameBuffer.width, height=frameHeight) newBuffer = Image(width=frameWidth, height=frameHeight) newBuffer.composite( frameBuffer, int((newBuffer.width - frameBuffer.width) / 2), int((newBuffer.height - frameBuffer.height) / 2), ) frameBuffer = newBuffer dirToFramesMapping[key] = frameBuffer directionAnimations = dict() for key, value in dirToFramesMapping.items(): directionAnimationBuffer = Image(width=frameWidth, height=frameHeight) directionAnimationBuffer.composite(value, 0, 0) directionAnimations[key] = directionAnimationBuffer animation = Image(width=frameWidth, height=frameHeight * len(directions)) animation.composite(directionAnimations["n"], 0, 0) animation.composite(directionAnimations["ne"], 0, frameHeight) animation.composite(directionAnimations["e"], 0, frameHeight * 2) animation.composite(directionAnimations["se"], 0, frameHeight * 3) animation.composite(directionAnimations["s"], 0, frameHeight * 4) animation.composite(directionAnimations["sw"], 0, frameHeight * 5) animation.composite(directionAnimations["w"], 0, frameHeight * 6) animation.composite(directionAnimations["nw"], 0, frameHeight * 7) animation.save(filename=animationDirectory + animationName + ".png")
def get_element_screenshot(element: WebElement) -> bytes: driver = element._parent ActionChains(driver).move_to_element(element).perform() # focus src_base64 = driver.get_screenshot_as_base64() scr_png = b64decode(src_base64) scr_img = Image(blob=scr_png) x = element.location["x"] + 750 y = element.location["y"] + 415 w = element.size["width"] h = element.size["height"] scr_img.crop( left=math.floor(x), top=math.floor(y), width=math.ceil(w), height=math.ceil(h), ) return scr_img.make_blob()
def resizeImage(imagePath, fullsize): mon_aspect = fullsize.x / fullsize.y img = Image(filename=imagePath) img_aspect = img.width / img.height if img_aspect > mon_aspect: if img.height >= fullsize.y: img.transform(resize='x' + str(fullsize.y)) leftc = (img.width - fullsize.x) / 2 leftc = round(leftc) print("everything trueee") img.crop(leftc, 0, width=fullsize.x, height=fullsize.y) else: print("img.height < fullsize.y") else: img.transform(resize=str(fullsize.x) + 'x') topc = (img.height - fullsize.y) / 2 topc = round(topc) img.crop(0, topc, width=fullsize.x, height=fullsize.y) return img
def open_image(path, colors, width=60, crop=None, gauge=[40, 40]): # Find height ratio height_ratio = gauge[1] / float(gauge[0]) # Open image, resize and posterize with open(path) as fp: # Open image image = Image(file=fp) # Crop if crop != None: image.crop(crop['x'], crop['y'], crop['w'] + crop['x'], crop['h'] + crop['y']) # Resize to width and height ratio resize(image, width, height_ratio) # Get data data = get_data( PImage.open(StringIO.StringIO(image.make_blob('ppm')))) # Posterize image to fewer colors return posterize(data, colors)
def post_process(self, ig, incoming): from qt import qt5 from qt.channels import InstagramPositioningAction from wand.image import Image location = '/tmp/instagram/temp_' + fixed.digest( ig[instagram_keys.instagram_url]) + '.png' qt5.app.toImage(location) instagram_action = InstagramPositioningAction() instagram_d = defer.Deferred() self.set_action(instagram_action, instagram_d) self.page().runJavaScript(instagram_action.js_script()) instagram_positioning = yield instagram_d print 'instagram positioning:', instagram_positioning if instagram_positioning: instagram_im = Image(filename=location) instagram_im.crop(left=instagram_positioning[3], top=instagram_positioning[0], right=instagram_positioning[1], bottom=instagram_positioning[2]) instagram_clip = '/tmp/instagram/instagram_' + fixed.digest( ig[instagram_keys.instagram_url]) + '.png' instagram_im.save(filename=instagram_clip) print 'send_image:', instagram_clip try: io = StringIO.StringIO(open(instagram_clip, 'r').read()).getvalue() fi = self.bundle_instagram(incoming._data, io) print 'send mime:', len(io) self.protocol.sendMessage(fi, True) except Exception as e: print 'send image exception:', e if Tweet.self_instagrams in incoming: for i in incoming[Tweet.self_instagrams]: self.check_avatar(incoming, i) elif Tweet.known_instagrams in incoming: for i in incoming[Tweet.known_instagrams]: self.check_avatar(i, i)
def load_one_bit_byte_array(image_filename): try: img = Image(filename=image_filename) # scale # option 1: seam carving #img.liquid_rescale(176,264) # option 2: scale with aspect ratio: img.transform(resize='176x264^') img.crop(width=176, height=264) # OrderedDitherImage would allow using 'h4x4a' dither but it's not in python API? img.type = 'bilevel' # screen is rotated img.rotate(90) # Write a binary array of b/w pixels return _image_to_one_bit_byte_array(img) except BlobError: img = None return None
def resize(self, img: WandImage, mult: float) -> WandImage: # No need to waste our resources for resizing by the same exact multiplier (1:1) if mult == 1.0: return img # Or even invalid multiplier (raise exception instead) elif mult <= 0: raise ValueError("Image resize multiplier must not be less than 0!") # Resize the image using the multiplier new_width = round(img.width * mult) new_height = round(img.height * mult) img.adaptive_resize(new_width, new_height) # Then crop the image so it's centered crop_left = round((self.max_width - img.width) / 2) if crop_left < 0: crop_left = 0 crop_right = crop_left + self.max_width if crop_right > img.width: crop_right = img.width img.crop(crop_left, 0, crop_right, self.max_height) return img
def create_image(path, width, height): image = Image(filename=path) if (image.width >= width or image.height >= height): # breite ist maßgebend h = height w = width if (image.width / width < image.height / height): h = int(round(image.height / (image.width / width))) # höhe ist maßgebend else: w = int(round(image.width / (image.height / height))) image.resize(w, h) image.crop(width=width, height=height, gravity='center') return image else: outerImg = Image(width=width, height=height, background=image[1][1]) outerImg.format = image.format.lower() outerImg.composite(image, left=int((width - image.width) / 2), top=int((height - image.height) / 2)) image.close() return outerImg
def do_cube(img): with WandImage(blob=img) as image: def s(x): return int(x / 3) image.resize(s(1000), s(860)) image.format = "png" image.alpha_channel = 'opaque' image1 = image image2 = WandImage(image1) out = WandImage(width=s(3000 - 450), height=s(860 - 100) * 3) out.format = "png" image1.shear(background=wand.color.Color("none"), x=-30) image1.rotate(-30) out.composite(image1, left=s(500 - 250), top=s(0 - 230) + s(118)) image1.close() image2.shear(background=wand.color.Color("rgba(0,0,0,0)"), x=30) image2.rotate(-30) image3 = WandImage(image2) out.composite(image2, left=s(1000 - 250) - s(72), top=s(860 - 230)) image2.close() image3.flip() out.composite(image3, left=s(0 - 250) + s(68), top=s(860 - 230)) image3.close() out.crop(left=80, top=40, right=665, bottom=710) buffer = BytesIO() out.save(buffer) buffer.seek(0) return buffer
def convert_pdf_to_jpg(tablename, nrows): print("Converting") path = os.getcwd() + '\\figures\\' filename = path + tablename + '_OUTPUT.pdf' img = Image(filename=filename, resolution=500) imgname = path + tablename + '_OUTPUT.jpeg' img.convert('jpeg').save(filename=imgname) import PIL img = PIL.Image.open(imgname) #打开图像 box = (360, 490, 3733, 510 + 95 * nrows) #根据nrows来剪裁图像 clip = img.crop(box) clip.save(imgname) os.remove(filename)
def convert_image( pngfile, pf, outdir=".", resize=1000, format="jpeg", rotate=0, rows=":", cols=":", labelrows=None, labelcols=None, ): resizefile = op.join(outdir, pf + ".resize.jpg") mainfile = op.join(outdir, pf + ".main.jpg") labelfile = op.join(outdir, pf + ".label.jpg") img = Image(filename=pngfile) exif = dict( (k, v) for k, v in img.metadata.items() if k.startswith("exif:")) # Rotation, slicing and cropping of main image if rotate: img.rotate(rotate) if resize: w, h = img.size if min(w, h) > resize: if w < h: nw, nh = resize, resize * h / w else: nw, nh = resize * w / h, resize img.resize(nw, nh) logging.debug( "Image `{0}` resized from {1}px:{2}px to {3}px:{4}px".format( pngfile, w, h, nw, nh)) img.format = format img.save(filename=resizefile) rimg = img.clone() if rows != ":" or cols != ":": w, h = img.size ra, rb = slice(rows, h) ca, cb = slice(cols, w) # left, top, right, bottom logging.debug("Crop image to {0}:{1} {2}:{3}".format(ra, rb, ca, cb)) img.crop(ca, ra, cb, rb) img.format = format img.save(filename=mainfile) else: mainfile = resizefile # Extract text labels from image if labelrows or labelcols: w, h = rimg.size if labelrows and not labelcols: labelcols = ":" if labelcols and not labelrows: labelrows = ":" ra, rb = slice(labelrows, h) ca, cb = slice(labelcols, w) logging.debug("Extract label from {0}:{1} {2}:{3}".format( ra, rb, ca, cb)) rimg.crop(ca, ra, cb, rb) rimg.format = format rimg.save(filename=labelfile) else: labelfile = None return resizefile, mainfile, labelfile, exif
color2 = color[3:6] color3 = color[6:9] # -------------------------------------------------------------- # ----------get the base layer texture-------------------------- Scenes = pathwalk('.\\SceneData\\') randomScene = random.choice(Scenes) randomScene = randomScene[0] + randomScene[1] # print(randomScene) randomSceneImage = Image(filename=randomScene) widthRange = randomSceneImage.size[0] - 100 heightRange = randomSceneImage.size[1] - 32 randomSceneImage.crop(left=random.randint(0, widthRange), top=random.randint(0, heightRange), width=100, height=32) # randomSceneImage.save(filename='.\\photoWand\\'+str(j+1) + '_texture.jpg') # -------------------------------------------------------------- # ----------create the base layer, base texture +base color----- baseImage = Image( width=100, height=32, background=Color('rgb(' + str(color1[0]) + ',' + str(color1[1]) + ',' + str(color1[2]) + ')')) # print('base_color = ' + 'rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')') baseImage.composite_channel(channel='undefined', image=randomSceneImage, operator='blend',
def compose_image_slide(self, image_path=None, text=None, slide_id=1): image_display_size = (300, 190) key = '%s-%s-%03d' % (self.emission.uuid, self.content_object.uuid, slide_id) path = os.path.join(SLIDE_BASE_DIR, key + '.{}'.format(IMAGE_OUTPUT_FORMAT)) url = SLIDE_BASE_URL + key + '.{}'.format(IMAGE_OUTPUT_FORMAT) overlay_image = Image(filename=image_path) with Drawing() as draw: size = overlay_image.size if size[0] > size[1]: orientation = 'landscape' scale = float(image_display_size[1]) / float(size[1]) else: orientation = 'portrait' scale = float(image_display_size[1]) / float(size[0]) overlay_image.resize(int(size[0] * scale), int(size[1] * scale)) #size = overlay_image.size width = 190 height = 190 overlay_image.crop(10, 0, width=width, height=height) draw.composite('over', left=int(width / 2) - 20, top=10, width=width, height=height, image=overlay_image) # text settings draw.font = SLIDE_BASE_FONT draw.font_size = 14 draw.text_interline_spacing = 8 draw.fill_color = Color('white') draw.text_antialias = True # draw text if text: draw.text(220, 10, text) # compose image with Image(filename=SLIDE_BASE_IMAGE) as image: draw(image) if IMAGE_OUTPUT_FORMAT == 'jpg': image.compression_quality = 62 image.format = 'jpeg' image.save(filename=path) image.save(filename=os.path.join( SLIDE_BASE_DIR, 'debug-{}.{}'.format( slide_id, IMAGE_OUTPUT_FORMAT))) try: overlay_image.close() except Exception as e: # TODO: use narrowed exception(s) log.warning( 'unable to close magick/wand overlay image - {}'.format(e)) return url
def benchmark(source): """ run through all tests, timing along the way timeit gets mentioned many times: http://docs.python.org/3.4/library/timeit.html """ print("Testing moments: ") start_time = time.time() print("making path:") step_time = time.time() pic = Path(source) print(time.time() - step_time, "seconds") print("") print("loading path:") step_time = time.time() img = pic.load() print(time.time() - step_time, "seconds") print("") #13.3232491016 seconds: ## print "make thumbs: (all)" ## step_time = time.time() ## img.make_thumbs() ## print time.time() - step_time, "seconds" ## print "" ## print "removing thumbs: (all)" ## step_time = time.time() ## shutil.rmtree("sized") ## print time.time() - step_time, "seconds" ## print "" #3.2377550602 seconds: ## print "make thumbs: (tiny)" ## step_time = time.time() ## img.make_thumbs(["tiny"]) ## print time.time() - step_time, "seconds" ## print "" ## print "removing thumbs: (tiny)" ## step_time = time.time() ## shutil.rmtree("sized") ## print time.time() - step_time, "seconds" ## print "" #now break it down to steps: #0.000612020492554 seconds ## print "make thumbs dirs()" ## step_time = time.time() ## img.make_thumb_dirs() ## print time.time() - step_time, "seconds" ## print "" ## print "removing thumbs dirs" ## step_time = time.time() ## shutil.rmtree("sized") ## print time.time() - step_time, "seconds" ## print "" #0.00586199760437 seconds print("Open image with PIL: ") step_time = time.time() image = PILImage.open(source) print(time.time() - step_time, "seconds") print("") print("show sizes: ") step_time = time.time() print(image.size) print(time.time() - step_time, "seconds") print("") #0.56491112709 seconds print("Copy image buffer in PIL: ") step_time = time.time() square = image.copy() print(time.time() - step_time, "seconds") print("") print("resize max: ") step_time = time.time() pre_crop = resize_max(400, image.size[0], image.size[1]) print(pre_crop) print(time.time() - step_time, "seconds") print("") #0.108213186264 seconds print("Square image (includes copy)") step_time = time.time() square = img._square_image(square) print(time.time() - step_time, "seconds") print("") #xl = 2880 #3.53499007225 seconds print("thumbnail image (2880, ANTIALIAS)") step_time = time.time() #image.thumbnail((xl,xl), PILImage.ANTIALIAS) square.thumbnail((400,400), PILImage.ANTIALIAS) print(time.time() - step_time, "seconds") print("") print("After thumbnail: ", image.size) print("") print("save thumb") step_time = time.time() #image.save("test.jpg", "JPEG") square.save("test1.jpg", "JPEG") print(time.time() - step_time, "seconds") print("") print("PIL alternative (total)") step_time = time.time() #img = resize_pil_orig(image, (400, 400)) img = resize_pil(image, 400) print(time.time() - step_time, "seconds") print("") img.save("test.jpg", "JPEG") #shutil.rmtree("sized") #os.remove("test.jpg") from wand.image import Image #0.572014093399 seconds print("wand open file") step_time = time.time() img = Image(filename=source) print(time.time() - step_time, "seconds") print("") print("wand clone image") step_time = time.time() clone = img.clone() print(time.time() - step_time, "seconds") print("") print("wand get dimensions") step_time = time.time() width = img.width height = img.height ## with Image(filename=source) as img: ## width = img.width ## height = img.height print(width, height) print(time.time() - step_time, "seconds") print("") print("wand crop image") step_time = time.time() box = calculate_box(img.width, img.height) img.crop(*box) print(time.time() - step_time, "seconds") print("") print("wand save image") step_time = time.time() img.save(filename='temp3.jpg') print(time.time() - step_time, "seconds") print("") #THIS TAKES A *LONG* TIME!!!! #273.595574856 seconds #and will only make a difference for certain types of images #made no difference for one test image ## print "wand liquid rescale" ## step_time = time.time() ## liquid = clone.liquid_rescale(400, 400) ## print time.time() - step_time, "seconds" ## print "" ## print "wand save liquid" ## step_time = time.time() ## img.save(filename='temp-liquid.jpg') ## print time.time() - step_time, "seconds" ## print "" #0.238882064819 seconds print("epeg resize") step_time = time.time() #TODO #consider using subprocess... #any benefits? #os.system("jhead -cmd \"jpegtran -progressive -rotate %s &i > &o\" %s" % (degrees, self.path)) os.system("epeg -m %s %s temp-epeg.jpg" % (pre_crop, source)) print(time.time() - step_time, "seconds") print("") ## print "Testing: " ## step_time = time.time() ## print source ## print time.time() - step_time, "seconds" ## print "" print("TOTAL TIME:") print(time.time() - start_time, "seconds")
def download_image(request, datafile_id, region, size, rotation, quality, format=None): #@ReservedAssignment # Get datafile (and return 404 if absent) try: datafile = DataFile.objects.get(pk=datafile_id) except DataFile.DoesNotExist: return HttpResponseNotFound() is_public = datafile.is_public() if not is_public: # Check users has access to datafile if not has_datafile_download_access(request=request, datafile_id=datafile.id): return HttpResponseNotFound() buf = StringIO() try: file_obj = datafile.get_image_data() if file_obj is None: return HttpResponseNotFound() from contextlib import closing with closing(file_obj) as f: with Image(file=f) as img: if len(img.sequence) > 1: img = Image(img.sequence[0]) # Handle region if region != 'full': x, y, w, h = map(int, region.split(',')) img.crop(x, y, width=w, height=h) # Handle size if size != 'full': # Check the image isn't empty if 0 in (img.height, img.width): return _bad_request('size', 'Cannot resize empty image') # Attempt resize if not _do_resize(img, size): return _bad_request('size', 'Invalid size argument: %s' % size) # Handle rotation if rotation: img.rotate(float(rotation)) # Handle quality (mostly by rejecting it) if quality not in ['native', 'color']: return _get_iiif_error('quality', 'This server does not support greyscale or bitonal quality.') # Handle format if format: mimetype = mimetypes.types_map['.%s' % format.lower()] img.format = format if mimetype not in ALLOWED_MIMETYPES: return _invalid_media_response() else: mimetype = datafile.get_mimetype() # If the native format is not allowed, pretend it doesn't exist. if mimetype not in ALLOWED_MIMETYPES: return HttpResponseNotFound() img.save(file=buf) response = HttpResponse(buf.getvalue(), content_type=mimetype) response['Content-Disposition'] = \ 'inline; filename="%s.%s"' % (datafile.filename, format) # Set Cache if is_public: patch_cache_control(response, public=True, max_age=MAX_AGE) else: patch_cache_control(response, private=True, max_age=MAX_AGE) return response except WandException: return HttpResponseNotFound() except ValueError: return HttpResponseNotFound() except IOError: return HttpResponseNotFound()
class Card(object): """Individual object containing an image and actions to manipulate it. Posible kwargs to __init__ are filename, file, image, blob. it will load the image from there""" def __init__(self, *args, **kwargs): """Init a new cards with *img* being a wand.image.Image object""" self.img = Image(*args, **kwargs) self.border = None self.changed = True self.pixmap() def __del__(self): self.img.destroy() def format(self, fmt=None): if fmt is None: return self.img.format.lower() else: self.img.format = fmt @set_changed def resize(self, width, height, newres=300): """Resize this card to (*width*, *height*) inches, with a resolution of *newres*""" self.img.transform(resize=str(int(width*newres)) + "x" + str(int(height*newres)) + "!") self.img.reset_coords() self.img.resolution = (newres, newres) return newres def width(self): return self.img.size[0] def height(self): return self.img.size[1] def reset_coords(self): self.img.reset_coords() @set_changed def set_border(self, border): """Set a new *border* for this card""" if self.border is not None: self.del_border() self.border = border with Color(self.border.colour) as colour: self.img.border(colour, self.border.wide, self.border.wide) @set_changed def crop(self, *args, **kwargs): """Crop this card *top*, *bottom*, *left* and *right* pixels""" w, h = self.img.size if "right" in kwargs: kwargs["right"] = w - kwargs["right"] if "bottom" in kwargs: kwargs["bottom"] = h - kwargs["bottom"] self.img.crop(*args, **kwargs) self.reset_coords() def del_border(self): """Remove the border of this card""" if self.border is not None: w = self.border.wide self.crop(top=w, bottom=w, right=w, left=w) self.border = None self.changed = True @set_changed def trim(self, fuzz=13): self.img.trim(fuzz=fuzz) self.reset_coords() def save_as(self, filename): """Save this card in a file named *filename*""" self.img.save(filename = filename) def split(self, rows, cols, separation=0): """Divide this cards in *rows* by *cols* cards, and returns a list""" width, hight = self.img.size width, hight = (int(width), int(hight)) cardWidth = (width - separation * (cols-1)) / cols cardHight = (hight - separation * (rows-1)) / rows res = [] for i in range(rows): for j in range(cols): with self.img.clone() as clon: clon.crop(top=i*cardHight+i*separation, width=cardWidth, left=j*cardWidth+j*separation, height=cardHight) clon.reset_coords() res.append(Card(image=clon)) return res @set_changed def round_corners(self): """Round the corners of the card (setting them to alpha)""" pass def clone(self): c = Card(image=self.img.clone()) c.border = self.border return c def pixmap(self): """Update and returns the pixmap (QPixmap) of the contained image""" if self.changed: self._pixmap = QPixmap(QImage.fromData(self.img.make_blob("jpg"), "jpg"))#self.img.format)) self.changed = False return self._pixmap
class Panel: def __init__(self, background=None, chars=None, scene=None, doublewide=False): if background is None: background = randomize_background() self.background = Image(filename=background) self.doublewide = doublewide if self.doublewide is True: self.background.crop(0, 0, self.background.height, self.background.height) self.background.transform(resize='1000x500^') self.background.transform('1000x500') else: self.background.crop(0, 0, self.background.height, self.background.height) self.background.transform(resize='500') self.background.transform(resize='500x500') self.chars = chars self.scene = scene draw.font = 'plugins/py_toon/fonts/DejaVuSansMono.ttf' draw.font_size = 15 draw.text_kerning = 1 draw.text_alignment = 'left' def setup(self): self.add_characters() self.speech_bubbles() self.background = self.render() return self.background def speech_bubbles(self): curx = 15 cury = 15 for action in self.scene[1]: actor = action[0] line = action[1] if not line: continue line = textwrap.fill(line, 20) metrics = draw.get_font_metrics(self.background, line, True) ctext = int(metrics.text_width / 2.0) draw.fill_color = Color('white') draw.stroke_color = Color('black') draw.stroke_width = 1.0 char_center = actor.img.x + int(actor.img.width / 2.0) text_center = int(metrics.text_width / 2.0) if len(self.scene[1]) == 1: cury = randrange(50, 125 + 20) else: max_y = cury + 20 if max_y < 1: max_y = 245 cury = randrange(cury, max_y) curx = char_center - text_center if curx < 25: curx = 25 if curx > self.background.width - int(metrics.text_width): curx = self.background.width - int(metrics.text_width) - 15 curx = int(curx) cury = int(cury) if line.strip() != '': draw.round_rectangle(curx - 10, cury, curx + metrics.text_width + 10, cury + metrics.text_height + 5, 5, 5) draw.fill_color = Color('black') draw.text(curx, cury + 15, line) curx += metrics.text_width + 10 cury += int(metrics.text_height + 10) def add_characters(self): parts = self.background.width / len(self.chars.keys()) curx = 0 cury = 0 char_count = 0 for i in self.chars.items(): char = i[1] if self.doublewide is True: #char.img.resize(175, 175) char.img.transform(resize='x150') else: char.img.resize(125, 125) ### contain the character in this "box" char_pos = curx + parts - char.img.width print 'char_pos:', char_pos if char_pos < 1: return 'Not enough space to fit everybody.' curx = randrange(curx, char_pos) cury = self.background.height - char.img.height char.img.x = curx char.img.y = cury char_count += 1 curx = parts * char_count if char_count == 2: char.flip() self.background.composite(char.img, char.img.x, char.img.y) draw(self.background) if char_count == 2: ### unflip char.flip() def render(self): if self.doublewide is False: self.background.border(Color('white'), 5, 5) else: self.background.border(Color('white'), 10, 10) draw(self.background) draw.clear() return self.background
user_document = input("Input document name in quotes (include .pdf): ") image_pdf = Image(filename=user_document, resolution=230) image_jpeg = image_pdf.convert('JPEG') print image_jpeg.size i = 1 first_page = image_jpeg.sequence[0] #Crop first page to get first name, date, patriarch name, etc. ? #FIGURE OUT CROP ISSUES ---- Creates a new paragraph at each new line on the PDF... img_page = Image(image=image_jpeg.sequence[0]) regular_page_height = int(0.9122734 * img_page.height) img_page.crop(int(0.0525909 * img_page.width), int(0.2575078 * img_page.height), width=int(0.8957759 * img_page.width), height=int(0.6813658 * img_page.height)) img_page.save(filename='PB-raw0.jpeg') top = Image(filename='PB-raw0.jpeg') for img in image_jpeg.sequence[1:]: img_page = Image(image=img) #img_page.crop(95,145,1845,2355) #LTRB img_page.crop(int(0.0525909 * img_page.width), int(0.05031 * img_page.height), width=int(0.8957759 * img_page.width), height=int(0.9122734 * img_page.height)) #req_image.append(img_page.make_blob('JPEG')) #print image_jpeg.crop(10, 20, width=45, height=220) img_page.save(filename='PB-raw' + str(i) + '.jpeg') i += 1 #with Image(filename='PB-raw0.jpeg') as top: with Image(width=top.width, height=(int(0.75 * top.height) + (regular_page_height * (i-1)))) as stitch:
def Recursar(self, numero_cupom_fiscal, ean_enviado, descricao_recurso): try: time.sleep(1) wait = WebDriverWait(self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//*[@id="edtNumeroGuia"]'))) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//*[@id="edtNumeroGuia"]'))) guia = self.browser.find_element_by_xpath( '//*[@id="edtNumeroGuia"]') guia.clear() clipboard.copy(str(numero_cupom_fiscal).zfill(11).strip()) guia.send_keys(Keys.CONTROL, 'v') wait = WebDriverWait(self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//*[@id="divGuias"]/div/fieldset/div[1]/div/div/a'))) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//*[@id="divGuias"]/div/fieldset/div[1]/div/div/a'))) self.browser.find_element_by_xpath( '//*[@id="divGuias"]/div/fieldset/div[1]/div/div/a').click() except TimeoutException as e: return { 'status_recurso': 'E', 'log_recurso': u'Não foi possível informar Cupom Fiscal para recursar!', 'print_recurso': None } try: wait = WebDriverWait(self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//*[@id="tabelaGuia"]/tbody/tr/td[1]'))) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//*[@id="tabelaGuia"]/tbody/tr/td[1]'))) self.browser.find_element_by_xpath( '//*[@id="tabelaGuia"]/tbody/tr/td[1]').click() except TimeoutException as e: return { 'status_recurso': 'E', 'log_recurso': u'Cupom Fiscal não localizado para recursar!', 'print_recurso': None } try: wait = WebDriverWait(self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr' ))) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr' ))) linhas_tabela = self.browser.find_elements_by_xpath( '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr') except TimeoutException as e: return { 'status_recurso': 'E', 'log_recurso': u'Cupom Fiscal não possui itens para recursar!', 'print_recurso': None } numero_linha = 1 for linha_tabela in linhas_tabela: ean_linha = self.browser.find_element_by_xpath( '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr[' + str(numero_linha) + ']/td[1]').text if ean_linha == str(ean_enviado).zfill(13).strip(): try: wait = WebDriverWait( self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait( self.browser, timeout_requisicoes ).until( EC.presence_of_element_located(( By.XPATH, '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr[' + str(numero_linha) + ']/td[7]/a[2]'))) wait = WebDriverWait( self.browser, timeout_requisicoes ).until( EC.element_to_be_clickable(( By.XPATH, '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr[' + str(numero_linha) + ']/td[7]/a[2]'))) self.browser.find_element_by_xpath( '//*[@id="divEventos"]/div[2]/fieldset/div/table/tbody/tr[' + str(numero_linha) + ']/td[7]/a[2]').click() wait = WebDriverWait( self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.presence_of_all_elements_located( (By.XPATH, '//div[starts-with(@id,"heading")]/h4/a'))) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//div[starts-with(@id,"heading")]/h4/a'))) wait = WebDriverWait( self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//div[starts-with(@id,"heading")]/h4/a'))) glosas = self.browser.find_elements_by_xpath( '//div[starts-with(@id,"heading")]/h4/a') except TimeoutException as e: return { 'status_recurso': 'E', 'log_recurso': u'Não foi possível encontrar motivos de glosas para recursar!', 'print_recurso': None } codigo_justificativa = None for glosa in glosas: try: if codigo_justificativa != glosa.get_attribute( 'href').replace( self.browser.current_url + 'justificativa', ''): time.sleep(1) codigo_justificativa = glosa.get_attribute( 'href').replace( self.browser.current_url + 'justificativa', '') glosa.click() wait = WebDriverWait( self.browser, timeout_requisicoes).until( lambda browser: self.browser. execute_script('return jQuery.active == 0' )) wait = WebDriverWait( self.browser, timeout_requisicoes ).until( EC.presence_of_element_located(( By.XPATH, '//*[@id="myModal"]/div/div/div/div/div/button' ))) wait = WebDriverWait( self.browser, timeout_requisicoes ).until( EC.element_to_be_clickable(( By.XPATH, '//*[@id="myModal"]/div/div/div/div/div/button' ))) self.browser.find_element_by_xpath( '//*[@id="myModal"]/div/div/div/div/div/button' ).click() wait = WebDriverWait( self.browser, timeout_requisicoes).until( lambda browser: self.browser. execute_script('return jQuery.active == 0' )) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//textarea[@id="j' + codigo_justificativa + '"]'))) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//textarea[@id="j' + codigo_justificativa + '"]'))) justificativa = self.browser.find_element_by_xpath( '//textarea[@id="j' + codigo_justificativa + '"]') justificativa.clear() justificativa.send_keys( unicode(descricao_recurso, 'iso-8859-1')) except TimeoutException as e: return { 'status_recurso': 'E', 'log_recurso': u'Não foi informar a justificativa para recursar!', 'print_recurso': None } wait = WebDriverWait(self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) tela_recurso = self.browser.find_element_by_xpath( '//div[@id="divJustificativaEvento"]/div/div') posicao = tela_recurso.location tamanho = tela_recurso.size print_screen = self.browser.get_screenshot_as_base64() print_screen = Image(blob=b64decode(print_screen)) print_screen.crop(left=int(posicao["x"]), top=int(posicao["y"]), width=int(tamanho["width"]), height=int(tamanho["height"])) print_screen.make_blob() try: wait = WebDriverWait( self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//*[@id="btnSalvarJustificativaEvento"]'))) wait = WebDriverWait( self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//*[@id="btnSalvarJustificativaEvento"]'))) self.browser.find_element_by_xpath( '//*[@id="btnSalvarJustificativaEvento"]').click() except TimeoutException as e: return { 'status_recurso': 'E', 'log_recurso': u'Não possível confirmar o recurso!', 'print_recurso': None } wait = WebDriverWait(self.browser, timeout_requisicoes).until( lambda browser: self.browser.execute_script( 'return jQuery.active == 0')) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.presence_of_element_located( (By.XPATH, '//*[@id="btnFecharJustificativaEvento"]'))) wait = WebDriverWait(self.browser, timeout_requisicoes).until( EC.element_to_be_clickable( (By.XPATH, '//*[@id="btnFecharJustificativaEvento"]'))) self.browser.find_element_by_xpath( '//*[@id="btnFecharJustificativaEvento"]').click() return { 'status_recurso': 'F', 'log_recurso': u'Recurso efetuado com sucesso!', 'print_recurso': print_screen } numero_linha = numero_linha + 1 return { 'status_recurso': 'E', 'log_recurso': u'EAN enviado não encontrado para recursar!', 'print_recurso': None }
def create_box(filepdf, page_num, page_width, page_height, top, left, bottom, right, quality=200, margin=0.1): #extract filename: filebasename = os.path.basename(pdf_path + filepdf) print("extracting box from %s..." % filepdf) #used to generate temp file name. uuid_set = str(uuid.uuid4().fields[-1])[:5] img = Image(filename=pdf_path + filepdf, resolution=200) #resize image img.resize(page_width, page_height) #crop image img.compression_quality = int(quality) #save box img.save(filename=path_temp + "%s.jpg" % (uuid_set)) print("temp pages saved.") #search all image in temp path. file name ends with uuid_set value list_im = glob.glob(path_temp + "%s*.jpg" % uuid_set) img_page = Image(filename=path_temp + "%s-%s.jpg" % (uuid_set, str(page_num - 1)), resolution=200) width, height = img_page.size #define zone to crop left = round(left * width / page_width) right = round(right * width / page_width) top = round(top * height / page_height) bottom = round(bottom * height / page_height) box_width = right - left box_height = bottom - top #add a margin around box left = round(left - margin * box_width) if round(left - margin * box_width) > 1 else 1 right = round(right + margin * box_width) if round( right + margin * box_width) < width - 1 else width - 1 top = round(top - margin * box_height) if round(top - margin * box_height) > 1 else 1 bottom = round(bottom + margin * box_height) if round( bottom + margin * box_height) < height - 1 else height - 1 #crop the file img_page.crop(left, top, right, bottom) print("saving the image...") img_page.compression_quality = quality img_page.save(filename=path_boxs + filepdf + "-%s_pn-%s_pw-%s_ph-%s_t-%s_l-%s_b-%s_r-%s.jpg" % (uuid_set, str(page_num), str(page_width), str(page_height), str(top), str(left), str(bottom), str(right))) for i in list_im: os.remove(i) return
def draw_lip(self, top=False, bottom=False): if "back" not in self.faces: return None if not (top ^ bottom): # 1 and only 1 of top or bottom should be true return None # First draw a full mask with the lip shape lip_full_mask_image = Image(width=math.ceil(self.tuckbox['width'] * POINT_PER_MM), height=math.ceil(self.lip_size() * POINT_PER_MM)) lip_full_draw = Drawing() lip_full_draw.scale(POINT_PER_MM, POINT_PER_MM) # This cannot be too "thin" or the floodfill later would spill over lip_full_draw.stroke_width = max(2 / POINT_PER_MM, RESOLUTION / (200 * POINT_PER_MM)) lip_full_draw.fill_color = Color('white') lip_full_draw.color(0, 0, 'reset') lip_full_draw.draw(lip_full_mask_image) lip_full_draw.stroke_color = Color('black') # 1/2 left of lip lip_full_draw.bezier([(0, self.lip_size()), (0, self.lip_size() - .75*self.lip_size()), (.2 * self.tuckbox['width'], self.lip_size() - self.lip_size()), (.5 * self.tuckbox['width'], self.lip_size() - self.lip_size())]) # 1/2 right of lip lip_full_draw.bezier([(self.tuckbox['width'], self.lip_size()), (self.tuckbox['width'], self.lip_size() - .75*self.lip_size()), (.8 * self.tuckbox['width'], self.lip_size() - self.lip_size()), (.5 * self.tuckbox['width'], self.lip_size() - self.lip_size())]) lip_full_draw.draw(lip_full_mask_image) lip_full_draw.fill_color = Color('black') lip_full_draw.border_color = Color('black') lip_full_draw.color(.5 * self.tuckbox['width'], 0.8*self.lip_size(), 'filltoborder') lip_full_draw.draw(lip_full_mask_image) if self.faces['back'][:1] == "#": lip_image = Image(width = lip_full_mask_image.width, height = lip_full_mask_image.height, background = Color(self.faces['back'])) else: # Prepare the front image angle = 180 if "back_angle" not in self.options else (self.options["back_angle"]+2)*90 if bottom: angle = (angle + 180) % 360 _, file_extension = os.path.splitext(self.faces['back']) tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) self.resize_rotate_image(self.faces['back'], tmp_file.name, angle, math.ceil(self.tuckbox['width'] * POINT_PER_MM), math.ceil(self.tuckbox['height'] * POINT_PER_MM)) lip_image = Image(filename=tmp_file.name) lip_image.crop(top=lip_image.height - lip_full_mask_image.height) # u = image pixel # h = height # j = row # Radius of the hold is {self.tuckbox['width']*.1} # if value is 1 (or more_, it's white # Top is the tip of the lip, bottom is attached to the box # finger_hold_size_save is the row # at which it should be no attenuation below finger_hold_size_save = str( int(lip_image.height - math.ceil(self.tuckbox['width'] * POINT_PER_MM * 0.1))) lip_image = lip_image.fx( "j>"+finger_hold_size_save+"?u:1+(u-1)*(j/"+finger_hold_size_save+")") lip_image.composite(operator='lighten', image=lip_full_mask_image) if bottom: lip_image.rotate(180) return lip_image
def generate(count): # ---------------get three colors------------------------------- colorString = random.choice(result) color = [] for i in colorString: color += [int(i)] # for i in range(len(color)): # color[i] = math.floor(color[i]/255*65535) color1 = color[0:3] color2 = color[3:6] color3 = color[6:9] # -------------------------------------------------------------- # ----------get the base layer texture-------------------------- Scenes = pathwalk('./SceneData') randomScene = random.choice(Scenes) randomScene = randomScene[0] + '/' + randomScene[1] print(randomScene) randomSceneImage = Image(filename=randomScene) widthRange = randomSceneImage.size[0] - 100 heightRange = randomSceneImage.size[1] - 32 randomSceneImage.crop(left=random.randint(0, widthRange), top=random.randint(0, heightRange), width=100, height=32) # randomSceneImage.save(filename='.\\photoWand\\'+str(j+1) + '_texture.jpg') # -------------------------------------------------------------- # ----------create the base layer, base texture +base color----- baseImage = Image(width=100, height=32, background=Color('rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')')) # print('base_color = ' + 'rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')') baseImage.composite_channel(channel='undefined', image=randomSceneImage, operator='blend', left=0, top=0) baseImage.gaussian_blur(4, 10) baseImage.resolution = (96, 96) # -------------------------------------------------------------- # -----generate font-------------------------------------------- word = randomWords() fonts = pathwalk('./fonts/font_en/') randomFont = random.choice(fonts) randomFont = randomFont[0] + randomFont[1] initialPointsize = 45 draw = Drawing() draw.font = randomFont tmp = int(math.floor(abs(random.gauss(0, 1))*6)) if random.randint(1, 2) == 1: rotateX = random.randint(0, tmp) else: rotateX = random.randint(360-tmp, 360) draw.rotate(rotateX) # -------------------------------------------------------------- # --------get suitable FontPointSize---------------------------- draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) while metric.text_width > 100 or metric.text_height > 36: initialPointsize -= 5 draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) # -------------------------------------------------------------- # ----------italic---------------------------------------------- if random.random() > 0.5: draw.font_style = 'italic' # -------------------------------------------------------------- # ----------underline------------------------------------------- if random.random() > 0.5: draw.text_decoration = 'underline' # -------------------------------------------------------------- # ----------gravity--------------------------------------------- draw.gravity = 'center' # -------------------------------------------------------------- # --------------shadow/border----------------------------------- if random.random() < 0.5: # shadow addx = math.ceil(random.gauss(0, 2)) addy = math.ceil(random.gauss(0, 2)) draw.fill_color = Color('black') draw.text(x=abs(int(addx)), y=abs(int(addy)), body=word) else: # border draw.stroke_color = Color('rgb('+str(color3[0])+','+str(color3[1])+','+str(color3[2])+')') draw.stroke_width = math.ceil(initialPointsize/10)-1 # -------------------------------------------------------------- # ----------print word------------------------------------------ draw.fill_color = Color('rgb('+str(color2[0])+','+str(color2[1])+','+str(color2[2])+')') draw.text(x=0, y=0, body=word) draw.draw(baseImage) # -------------------------------------------------------------- # ------------gray---------------------------------------------- baseImage.colorspace = 'gray' # -------------------------------------------------------------- print(word) baseImage.save(filename='./photo_en/'+str(count+1)+'_'+word+'.jpg')
def process_image(raw_queue, ready_queue, global_config): from wand.image import Image # get an image from the queue try: image_config = raw_queue.get() except Queue.Empty: return image = Image(filename=image_config['filename']) raw_areas = [] all_areas = [] done = [] temp_areas = [i for i in image_config.keys() if i[:4].lower() == 'area'] for area in temp_areas: area = image_config[area] raw_areas.append(tuple([float(i) for i in area.split(',')])) temp_positions = [ i for i in image_config.keys() if i[:8].lower() == 'position' ] for pos in temp_positions: pos = image_config[pos] if global_config['units'] == 'pixels': x, y = [int(i) for i in pos.split(',')] w, h = image.size else: x, y = [int(int(i) * global_config['dpi']) for i in pos.split(',')] w, h = [int(int(i) / global_config['dpi']) for i in image.size] this_config = dict(image_config) this_config['area'] = (x, y, w, h) ready_queue.put(this_config) #raw_areas.append((x,y,w,h)) # REWRITE THIS! for area in raw_areas: if global_config['units'] == 'pixels': x, y, w, h = [int(i) for i in area] else: x, y, w, h = [int(float((i)) * global_config['dpi']) for i in area] all_areas.append((x, y, w, h)) # process each image for x, y, w, h in all_areas: if (w, h) not in done: # A U T O C R O P autocrop = image_config.get('autocrop', None) if autocrop: r0 = float(w) / h r1 = float(image.width) / image.height if r1 > r0: scale = float(h) / image.height sw = int(image.width * scale) cx = int((sw - w) / 2) image.resize(sw, h) image.crop(left=cx, width=sw, height=h) # S C A L E scale = image_config.get('scale', None) if scale: image.resize(w, h) # F I L T E R S """ filters make heavy use of subprocess, so we need to make a temporary file for it to manipulate. """ filter = image_config.get('filter', None) if filter: scratch = 'prefilter-{}.miff'.format(image_config['filename']) image.filename = image_config['filename'] image.format = os.path.splitext(scratch)[1][1:] image.save(filename=scratch) image.close() image = None if filter.lower() == 'toaster': scratch = toaster(scratch, sw, h) # create a new Image object for the queue with Image(filename=scratch) as temp_image: image = Image(image=temp_image) del temp_image # delete our temporary image file os.unlink(scratch) image.format = 'png' image.save(filename=image_config['filename']) image.close() done.append((w, h)) this_config = dict(image_config) this_config['area'] = (x, y, w, h) ready_queue.put(this_config) ready_queue.close() raw_queue.task_done()
color1 = color[0:3] color2 = color[3:6] color3 = color[6:9] # -------------------------------------------------------------- # ----------get the base layer texture-------------------------- Scenes = pathwalk('.\\SceneData\\') randomScene = random.choice(Scenes) randomScene = randomScene[0] + randomScene[1] # print(randomScene) randomSceneImage = Image(filename=randomScene) widthRange = randomSceneImage.size[0] - 100 heightRange = randomSceneImage.size[1] - 32 randomSceneImage.crop(left=random.randint(0, widthRange), top=random.randint(0, heightRange), width=100, height=32) # randomSceneImage.save(filename='.\\photoWand\\'+str(j+1) + '_texture.jpg') # -------------------------------------------------------------- # ----------create the base layer, base texture +base color----- baseImage = Image(width=100, height=32, background=Color('rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')')) # print('base_color = ' + 'rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')') baseImage.composite_channel(channel='undefined', image=randomSceneImage, operator='blend', left=0, top=0) baseImage.gaussian_blur(4, 10) baseImage.resolution = (96, 96) # -------------------------------------------------------------- # -----generate font-------------------------------------------- word = python2access.randomWords() fonts = pathwalk('.\\googleFonts\\')
def crop(jpeg, width=128, height=171): """Returns a cropped version of an image""" img = Image(blob=jpeg) img.crop(left=3, top=3, width=width, height=height) return img.make_blob()
class Render: def __init__(self, geojson, width=1024, height=1024): self.minxtile = 0 self.minytile = 0 self.number_of_rows = 0 self.number_of_cols = 0 self.rendering_zoom = 13 self.tile_provider = 'OCM' self.square_rendering = False self.center = 0 self.stroke_width = 3 self.render_width = int(width) self.render_height = int(height) self.width_in_pixel = 0 self.height_in_pixel = 0 self.bounds = '' self.rendering_bounds = '' self.tile_cache_path = './cache' self.cache_path = '' self.img = '' self.debug = False self.render_quality = 90 self.geojson = json.loads(geojson) self.prepare() def init_cache(self): self.cache_path = self.get_cache_path() if not os.path.isdir(self.cache_path): os.makedirs(self.cache_path) def get_cache_path(self): return "%s/%s/%s" % (self.tile_cache_path, self.tile_provider, self.rendering_zoom) def get_tile(self, tile): tile_path = "%s/%s/%s.png" % (self.cache_path, tile[0], tile[1]) if not os.path.exists(tile_path) : tile_dir = os.path.dirname(tile_path) if not os.path.isdir(tile_dir): os.makedirs(tile_dir) url = self.get_tile_url(tile) response = urlopen(url) url = self.get_tile_url(tile) f = open(tile_path, 'w+') f.write(response.read()) f = open(tile_path, 'r') return f def prepare(self): self.get_bounds() self.define_zoom_level() self.get_rendering_bounds() self.init_cache() def process(self): tiles = self.get_tiles_for_bounds() self.generate_background(tiles) return self.generate_track() def define_zoom_level(self) : """ Define the best zoom level giving the specified size for the image. Starting from the higher zoom level (18) then decrementing to get the best level. """ self.rendering_zoom = 18 self.get_size_from_bounds_and_zoom_level() while (self.width_in_pixel > self.render_width or self.height_in_pixel > self.render_height) and self.rendering_zoom > 1 : self.rendering_zoom = self.rendering_zoom - 1 self.get_size_from_bounds_and_zoom_level() print "define_zoom_level w: %s, h: %s, z: %s" % (self.width_in_pixel, self.height_in_pixel, self.rendering_zoom) def get_bounds(self): max = np.max(self.geojson['coordinates'], axis=0) max_lon = max[0] max_lat = max[1] max_ele = max[2] min = np.min(self.geojson['coordinates'], axis=0) min_lon = min[0] min_lat = min[1] min_ele = min[2] self.bounds = Bounds(min_lon, max_lon, min_lat, max_lat) def get_rendering_bounds(self): center_lat = (self.bounds.se.lat + self.bounds.nw.lat) / 2.0 center_lon = (self.bounds.se.lon + self.bounds.nw.lon) / 2.0 center = Point(center_lon, center_lat) center.project(self.rendering_zoom) self.center = center top_left_x = center.x - (self.render_width / 2.0) top_left_y = center.y - (self.render_height / 2.0) top_left = Point.from_xy(top_left_x, top_left_y) top_left.unproject(self.rendering_zoom) bottom_x = center.x + (self.render_width / 2.0) bottom_y = center.y + (self.render_height / 2.0) bottom_right = Point.from_xy(bottom_x, bottom_y) bottom_right.unproject(self.rendering_zoom) self.rendering_bounds = Bounds(top_left.lon, bottom_right.lon, bottom_right.lat, top_left.lat) print self.rendering_bounds def get_size_from_bounds_and_zoom_level(self): # top left point top_left = Point(self.bounds.nw.lon, self.bounds.nw.lat) top_left.project(self.rendering_zoom) # top right point top_right = Point(self.bounds.se.lon, self.bounds.nw.lat) top_right.project(self.rendering_zoom) # calculate width in px width = math.fabs(top_left.x-top_right.x) # bottom left point bottom_left = Point(self.bounds.nw.lon, self.bounds.se.lat) bottom_left.project(self.rendering_zoom) # calculte height in px height = math.fabs(top_left.y-bottom_left.y) self.width_in_pixel = width self.height_in_pixel = height def get_tiles_for_bounds(self): """ Returns a matrix of tile corresponding to the bounds """ self.rendering_bounds.nw.project(self.rendering_zoom) self.rendering_bounds.se.project(self.rendering_zoom) nw_tile_x, nw_tile_y = self.rendering_bounds.nw.get_tile() se_tile_x, se_tile_y = self.rendering_bounds.se.get_tile() x = [int(nw_tile_x), int(se_tile_x)] x.sort() y = [int(nw_tile_y), int(se_tile_y)] y.sort() # Create the range of the tiles tile_x_range = range(x[0], x[1]+1) tile_y_range = range(y[0], y[1]+1) self.number_of_cols = len(tile_x_range) self.number_of_rows = len(tile_y_range) self.minxtile = tile_x_range[0] self.minytile = tile_y_range[0] i = 0 # Create a Matrix of tiles matrix = [[0 for x in range(self.number_of_cols)] for y in range(self.number_of_rows)] # Loop over the rows (y tiles) for y_tile in tile_y_range: j = 0 # Loop over the columns (x tiles) for x_tile in tile_x_range: matrix[i][j] = [x_tile, y_tile] # increment the columns j += 1 # increment lines i += 1 return matrix def generate_background(self, tiles) : """ Displays the tiles on the background """ self.img = Image(width=self.number_of_cols*256, height=self.number_of_rows*256) current_row = 0 for row in tiles : current_col = 0 for tile in row: response = self.get_tile(tile) try: with Image(file=response) as tile_img: draw = Drawing() draw.composite(operator='add', left=current_col*256, top=current_row*256, width=tile_img.width, height=tile_img.height, image=tile_img) draw(self.img) finally: response.close() current_col += 1 current_row += 1 def get_tile_url(self, tile) : """ Returns the url for a specified tile """ return "http://tile.openstreetmap.org/%s/%s/%s.png" % (self.rendering_zoom, tile[0], tile[1]) def generate_track(self) : draw = Drawing() draw.stroke_width = 2 draw.stroke_color = Color('red') draw.fill_color = Color('transparent') points = [] # Loop over the coordinates to create a list of tuples for coords in self.geojson['coordinates'] : pt = Point(coords[0], coords[1]) pt.project(self.rendering_zoom) x, y = pt.get_xy() x = round(x - (self.minxtile * 256)) y = round(y - (self.minytile * 256)) points.append((x, y)) # draw the polyline draw.polyline(points) # apply to the image draw(self.img) # self.rendering_bounds.nw.project(self.rendering_zoom) x = int(self.rendering_bounds.nw.tile_x - self.minxtile) y = int(self.rendering_bounds.nw.tile_y - self.minytile) self.crop(x, y) self.img.format = 'jpeg' # self.img.save(filename='image.jpg') return self.img.make_blob('jpeg') def crop(self, x, y): x = self.rendering_bounds.nw.x - (self.minxtile * 256) y = self.rendering_bounds.nw.y - (self.minytile * 256) self.img.crop(int(x), int(y), width=self.render_width, height=self.render_height)
def _extract_qp(self, file_name): mark_sum = 0 print "Extracting QP" # Load pdf laparams = LAParams() rsrcmgr = PDFResourceManager() document = file(file_name, 'rb') device = PDFPageAggregator(rsrcmgr, laparams=laparams) interpreter = PDFPageInterpreter(rsrcmgr, device) q_num = 0 for i, page in enumerate(PDFPage.get_pages(document)): # Get page layout interpreter.process_page(page) layout = device.get_result() # Extract metadata textboxes = [ r for r in layout._objs if type(r) is LTTextBoxHorizontal ] work_out_y = 0 answer_header = 0 marks = [] for t in textboxes: text = t.get_text() if "Answer space for question" in text: work_out_y = int(t.y0) elif "marks]" in text: marks.extend(find_between(text, "[", " marks]")) elif "mark]" in text: marks.extend(find_between(text, "[", " mark]")) elif "......" in text: # TODO: Find the correct amount of dots pass elif text in ["QUESTION\n", "PART\n", "REFERENCE\n"]: pass elif text in [ "Do not write\noutside the\n", "box\n", "Turn over s\n" ]: pass elif text == "Answer all questions.\n": answer_header = 74 else: pass # print repr(text) marks = [int(m) for m in marks] mark_sum += sum(marks) # Comver page into image img_path = "{}[{}]".format(file_name, i) img = Image(filename=img_path, resolution=int(72 * Paper.QUALITY)) # Set crop positions x = 46 * Paper.QUALITY y = (66 + answer_header) * Paper.QUALITY width = 489 * Paper.QUALITY height = (761 - answer_header - work_out_y) * Paper.QUALITY # Check for blank pages if height <= Paper.QUALITY or work_out_y <= 0: continue # Crop and save the image q_num += 1 img.crop(x, y, width=width, height=height) img_path = os.path.join(self._folder, "q{}.jpg".format(q_num)) img.save(filename=img_path) # Add question to questions self._questions.append(Question(img_path, q_num, marks)) print "Marks: {}".format(mark_sum)
def process(self, descriptor: StreamDescriptor, context: dict): # Ensuring the wand package is installed. ensure_wand() # noinspection PyPackageRequirements from wand.image import Image as WandImage # Copy the original info # generating thumbnail and storing in buffer # noinspection PyTypeChecker img = WandImage(file=descriptor) if self.crop is None and ( self.format is None or img.format == self.format) and ( (self.width is None or img.width == self.width) and (self.height is None or img.height == self.height)): img.close() descriptor.prepare_to_read(backend='memory') return if 'length' in context: del context['length'] # opening the original file output_buffer = io.BytesIO() with img: # Changing format if required. if self.format and img.format != self.format: img.format = self.format # Changing dimension if required. if self.width or self.height: width, height, _ = validate_width_height_ratio( self.width, self.height, None) img.resize( width(img.size) if callable(width) else width, height(img.size) if callable(height) else height) # Cropping if self.crop: img.crop( **{ key: int( int(value[:-1]) / 100 * (img.width if key in ('width', 'left', 'right') else img.height) ) if key in ('left', 'top', 'right', 'bottom', 'width', 'height') and isinstance(value, str) and '%' in value else value for key, value in self.crop.items() }) img.save(file=output_buffer) context.update(content_type=img.mimetype, width=img.width, height=img.height, extension=guess_extension(img.mimetype)) output_buffer.seek(0) descriptor.replace(output_buffer, position=0, **context)
def compose(self, image): utils.logger.info('Starting to compose Akari...') if 'akari:frames' not in cache: # cache miss utils.logger.warning('Akari frames were not warmed up!') self.warmup() akari_frames = cache.get('akari:frames') self.width = cache.get('akari:width') self.height = cache.get('akari:height') if self.type == 'animation' and len(akari_frames) < 2: # if we were asked to generate an animation but there's only one # mask, then we're generating a still image self.type = 'still' elif self.type == 'still' and len(akari_frames) > 1: # if we were asked to generate a still image and there are several # masks, use only the first one akari_frames = [akari_frames[0]] # now, get the background image filename = image.filename with Image(filename=filename) as original: # if it's an animation, take only the first frame if original.animation: bg_img = Image(original.sequence[0]) else: bg_img = Image(original) # remove the alpha channel, if any bg_img.alpha_channel = False # resize it bg_img.transform(resize='{}x{}^'.format(self.width, self.height)) bg_img.crop(width=self.width, height=self.height, gravity='center') if self.text: # generate the drawing to be applied to each frame if self.caption_type == 'seinfeld': caption, drawing = self._caption_seinfeld() elif self.caption_type == 'sanandreas': caption, drawing = self._caption_sanandreas() else: caption, drawing = self._caption_akari() else: caption, drawing = '', None result = Image() # this will be the resulting image for akari_frame in akari_frames: # take the background image this_frame = Image(bg_img) # put akari on top of it this_frame.composite(akari_frame, left=0, top=0) if drawing: # draw the caption on this frame drawing(this_frame) if len(akari_frames) == 1: # we are done already result = Image(this_frame) else: # add the frame to the result image result.sequence.append(this_frame) with result.sequence[-1]: result.sequence[-1].delay = 10 # remove this frame from memory (it's in the sequence already) this_frame.close() if not akari_frames: # shortcut in case there's no mask this_frame = Image(bg_img) if drawing: drawing(this_frame) result = Image(this_frame) this_frame.close() # save the result filename = image.get_path(self.type) result.compression_quality = 100 result.save(filename=filename) # destroy everything if drawing: drawing.destroy() for frame in result.sequence: frame.destroy() result.close() bg_img.close() try: # if the gif is too big, it has to be discarded. a new one # will be generated using a different image this time. if os.path.getsize(filename) > 3072 * 1024: raise AkariTooBigError('Composed an animation that is too big') except FileNotFoundError: # sometimes Wand fails to save the animation, and does not even # raise an exception. retry in this case. raise AkariWandIsRetardedError('Wand failed to save the animation') utils.logger.info('Akari composed and saved as "%s"', filename) self.filename = filename self.caption = caption
lines[2] = min(difference_to_middle_bottom) return lines #For all the png in the folder for filename in glob.glob("*-t.png"): im = Image(filename=filename) #Save the widht and height of the thumbnail th = im.height tw = im.width #Crop the image l = crop_image(im) top = l[1] bottom = l[2] im.crop(0,l[1],im.width,l[2]) #We rotate so we can use the same code! im.rotate(90) print im.height, im.width l = crop_image(im) im.crop(0,l[1],im.width,l[2]) left = l[1] right = l[2] im.rotate(-90) #We open the original image so we can crop it too original = filename.replace('-t','') oim = Image(filename=original) ow = oim.width oh = oim.height oim.crop((left * ow) /tw,(top * oh) / th,(right * ow) / tw,(bottom * oh) / th) im.save(filename=filename+'crop.png')
''' End of configuration ''' if DEBUG_DIR: os.mkdir(DEBUG_DIR) pair_file = open(PAIR_FILE, 'a') view_file = open(VIEW_FILE, 'a') mask_input = None if MASK_IMAGE_FILE: mask_input = Image(filename=MASK_IMAGE_FILE) mask_input.crop(CROP_LEFT, CROP_TOP, mask_input.width - CROP_RIGHT, mask_input.height - CROP_BOTTOM) mask_input.rotate(ROTATE) background = None background_cv = None for led_index in range(START_LED, TOTAL_LEDS): # resolve background potential_background = "%s/%05d-background.jpg" % (PHOTO_DIR, led_index) if os.path.isfile(potential_background): background = Image(filename=potential_background) background.crop(CROP_LEFT, CROP_TOP, background.width - CROP_RIGHT, background.height - CROP_BOTTOM) background.rotate(ROTATE) if mask_input: background.composite(mask_input)
print(img+" bad image") continue # If image is broken we continue our loop ignoring it else: orIm = Image(filename=img) # Read the image image = cv2.imread(img) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # opencv need black and white picture # Detect faces in the image faces = faceCascade.detectMultiScale( gray, # image for detection scaleFactor=1.1, # you can adjust this params to increase detection quality minNeighbors=5, # and minSize=(30, 30) # this too #flags = cv2.CV_HAAR_SCALE_IMAGE ) i=1 # counnter # Edit image and save it to data folder for (x, y, w, h) in faces: imgg=Image(filename=img) orIm.crop(x,y,x+w,y+h) # croping out face orIm.resize(256,256) # face image resizing orIm.save(filename=img.replace('images/','exit_data/'+str(i))) # save it to data folder orIm = Image(imgg) # if picture has more than 1 face reload it i+=1
def download_image(request, datafile_id, region, size, rotation, quality, format=None): #@ReservedAssignment # Get datafile (and return 404 if absent) try: datafile = DataFile.objects.get(pk=datafile_id) except DataFile.DoesNotExist: return HttpResponseNotFound() is_public = datafile.is_public() if not is_public: # Check users has access to datafile if not has_datafile_download_access(request=request, datafile_id=datafile.id): return HttpResponseNotFound() buf = StringIO() try: file_obj = datafile.get_image_data() if file_obj is None: return HttpResponseNotFound() from contextlib import closing with closing(file_obj) as f: with Image(file=f) as img: if len(img.sequence) > 1: img = Image(img.sequence[0]) # Handle region if region != 'full': x, y, w, h = map(int, region.split(',')) img.crop(x, y, width=w, height=h) # Handle size if size != 'full': # Check the image isn't empty if 0 in (img.height, img.width): return _bad_request('size', 'Cannot resize empty image') # Attempt resize if not _do_resize(img, size): return _bad_request('size', 'Invalid size argument: %s' % size) # Handle rotation if rotation: img.rotate(float(rotation)) # Handle quality (mostly by rejecting it) if quality not in ['native', 'color']: return _get_iiif_error( 'quality', 'This server does not support greyscale or bitonal quality.' ) # Handle format if format: mimetype = mimetypes.types_map['.%s' % format.lower()] img.format = format if mimetype not in ALLOWED_MIMETYPES: return _invalid_media_response() else: mimetype = datafile.get_mimetype() # If the native format is not allowed, pretend it doesn't exist. if mimetype not in ALLOWED_MIMETYPES: return HttpResponseNotFound() img.save(file=buf) response = HttpResponse(buf.getvalue(), content_type=mimetype) response['Content-Disposition'] = \ 'inline; filename="%s.%s"' % (datafile.filename, format) # Set Cache if is_public: patch_cache_control(response, public=True, max_age=MAX_AGE) else: patch_cache_control(response, private=True, max_age=MAX_AGE) return response except WandException: return HttpResponseNotFound() except ValueError: return HttpResponseNotFound() except IOError: return HttpResponseNotFound()
class Composer: def __init__(self, filename): self.filename = filename self.bg_img = None def load_image(self): with Image(filename=self.filename) as original: self.bg_img = Image(original) # remove the alpha channel, if any self.bg_img.alpha_channel = False def save_image(self, filename): self.bg_img.compression_quality = 100 self.bg_img.save(filename=filename) return filename @staticmethod def generate_filename(filename, i=None): filename = filename.replace('/', '_') if i is not None: return 'tmp/masked_%s_%03d.jpg' % (filename, i) return 'tmp/masked_%s' % filename def compose_photo_visitelche(self): def clamp(number, minn, maxn): return max(min(maxn, number), minn) self.load_image() mask_img = Image(filename='assets/elche.png') mask_w = (self.bg_img.width / 2) * (self.bg_img.height / self.bg_img.width) mask_w = clamp(mask_w, self.bg_img.width / 2.5, self.bg_img.width / 1.5) mask_w = int(mask_w) mask_h = self.bg_img.height mask_img.transform(resize='%dx%d' % (mask_w, mask_h)) self.bg_img.composite(mask_img, left=self.bg_img.width - mask_w, top=0) return self.save_image(self.generate_filename(self.filename)) def compose_photo_bulo(self): return self._compose_photo_simple( ['assets/bulo%d.png' % random.randint(1, 3)]) def compose_photo_superbulo(self): return self._compose_photo_simple( ['assets/bulo%d.png' % i for i in range(1, 4)]) def _compose_photo_simple(self, filenames): self.load_image() for filename in filenames: mask_img = Image(filename=filename) mask_img.transform(resize='%dx%d' % (self.bg_img.width, self.bg_img.height)) self.bg_img.composite(mask_img, gravity='center') return self.save_image(self.generate_filename(self.filename)) def compose_file_visitelche(self): return self._compose_file_simple(FFMPEG_CMD_VISITELCHE) def compose_file_pescanova(self): return self._compose_file_simple(FFMPEG_CMD_PESCANOVA) def _compose_file_simple(self, cmd): file_dest = self.generate_filename(self.filename) subprocess.call(cmd.format(source=self.filename, dest=file_dest), shell=True) if not os.path.exists(file_dest): raise ValueError('ffmpeg did not output anything') return file_dest async def compose_photo_alvise(self, text=None, **kwargs): self.load_image() frame = await self._compose_alvise(self.bg_img, text=text, count=1) return frame[0] async def compose_file_megaalvise(self, text=None, **kwargs): self.load_image() file_dest = self.generate_filename(self.filename) + '.mp4' glob = self.generate_filename(self.filename) + '_*.jpg' invalid_w, invalid_h = self.bg_img.width % 2 == 1, self.bg_img.height % 2 == 1 if invalid_w or invalid_h: self.bg_img.crop(0, 0, width=self.bg_img.width - 1 if invalid_w else self.bg_img.width, height=self.bg_img.height - 1 if invalid_h else self.bg_img.height) await self._compose_alvise(self.bg_img, text=text, count=MEGAALVISE_FRAME_COUNT, callback=kwargs.get('callback'), callback_args=kwargs.get('callback_args')) if kwargs.get('callback') and kwargs.get('callback_args'): await kwargs.get('callback')(kwargs.get('callback_args')[0], MEGAALVISE_FRAME_COUNT, MEGAALVISE_FRAME_COUNT) cmd = FFMPEG_CMD_MEGAALVISE.format(source=glob, dest=file_dest) subprocess.call(cmd, shell=True) if not os.path.exists(file_dest): raise ValueError('ffmpeg did not output anything') return file_dest async def _compose_alvise(self, bg_img, text=None, count=1, **kwargs): with Drawing() as drawing: # fill the drawing primitives drawing.font = 'assets/HelveticaNeueLTCom-Md.ttf' drawing.gravity = 'north_west' drawing.fill_color = Color('#56fdb4') text = text if text else '@Alvisepf' # try to determine what a good font size would be string_list = text.split('\n') longest_string = len(max(string_list, key=len)) line_count = len(string_list) drawing.font_size = max( min(bg_img.width / longest_string * 1.5, bg_img.height / line_count * 1.5), 4) # the drawing has some padding so ascenders and descenders do not get truncated metrics = drawing.get_font_metrics(bg_img, text, '\n' in text) mask_w_orig, mask_h_orig = metrics.text_width, metrics.text_height + metrics.descender mask_w, mask_h = int(mask_w_orig * 1.02), int(mask_h_orig * 1.1) drawing.text(int((mask_w - mask_w_orig) / 2), int((mask_h - mask_h_orig) / 2), text) # create a mask image to draw the text on to, and... with Image(width=mask_w, height=mask_h) as mask_img: # draw the text into the mask image drawing.draw(mask_img) original_mask_img = Image(mask_img) frames = [] for i in range(count): mask_img = Image(original_mask_img) # rotate the mask mask_img.rotate(random.uniform(-35, -5)) # calculate what a smaller background image would look like scaling_factor = random.uniform(.5, .7) bg_img_scaled_w = bg_img.width * scaling_factor bg_img_scaled_h = bg_img.height * scaling_factor # scale the mask to fit into that smaller background image mask_img.transform(resize='%dx%d' % (bg_img_scaled_w, bg_img_scaled_h)) # calculate a random position inside the background image for it offset_left = random.randint(0, bg_img.width - mask_img.width) offset_top = random.randint( 0, bg_img.height - mask_img.height) # and put the mask in the image bg_img.composite(mask_img, left=offset_left, top=offset_top) frames.append( self.save_image( self.generate_filename(self.filename, i))) if kwargs.get('callback') and kwargs.get('callback_args'): await kwargs.get('callback')( kwargs.get('callback_args')[0], i, count) original_mask_img.destroy() return frames
def generate(count): # ---------------get three colors------------------------------- colorString = random.choice(result) color = [] for i in colorString: color += [int(i)] # for i in range(len(color)): # color[i] = math.floor(color[i]/255*65535) color1 = color[0:3] color2 = color[3:6] color3 = color[6:9] # -------------------------------------------------------------- # ----------get the base layer texture-------------------------- Scenes = pathwalk('./SceneData') randomScene = random.choice(Scenes) randomScene = randomScene[0] + '/' + randomScene[1] print(randomScene) randomSceneImage = Image(filename=randomScene) widthRange = randomSceneImage.size[0] - 100 heightRange = randomSceneImage.size[1] - 32 randomSceneImage.crop(left=random.randint(0, widthRange), top=random.randint(0, heightRange), width=100, height=32) # randomSceneImage.save(filename='.\\photoWand\\'+str(j+1) + '_texture.jpg') # -------------------------------------------------------------- # ----------create the base layer, base texture +base color----- baseImage = Image( width=100, height=32, background=Color('rgb(' + str(color1[0]) + ',' + str(color1[1]) + ',' + str(color1[2]) + ')')) # print('base_color = ' + 'rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')') baseImage.composite_channel(channel='undefined', image=randomSceneImage, operator='blend', left=0, top=0) baseImage.gaussian_blur(4, 10) baseImage.resolution = (96, 96) # -------------------------------------------------------------- # -----generate font-------------------------------------------- word = randomWords() fonts = pathwalk('./fonts/font_en/') randomFont = random.choice(fonts) randomFont = randomFont[0] + randomFont[1] initialPointsize = 45 draw = Drawing() draw.font = randomFont tmp = int(math.floor(abs(random.gauss(0, 1)) * 6)) if random.randint(1, 2) == 1: rotateX = random.randint(0, tmp) else: rotateX = random.randint(360 - tmp, 360) draw.rotate(rotateX) # -------------------------------------------------------------- # --------get suitable FontPointSize---------------------------- draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) while metric.text_width > 100 or metric.text_height > 36: initialPointsize -= 5 draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) # -------------------------------------------------------------- # ----------italic---------------------------------------------- if random.random() > 0.5: draw.font_style = 'italic' # -------------------------------------------------------------- # ----------underline------------------------------------------- if random.random() > 0.5: draw.text_decoration = 'underline' # -------------------------------------------------------------- # ----------gravity--------------------------------------------- draw.gravity = 'center' # -------------------------------------------------------------- # --------------shadow/border----------------------------------- if random.random() < 0.5: # shadow addx = math.ceil(random.gauss(0, 2)) addy = math.ceil(random.gauss(0, 2)) draw.fill_color = Color('black') draw.text(x=abs(int(addx)), y=abs(int(addy)), body=word) else: # border draw.stroke_color = Color('rgb(' + str(color3[0]) + ',' + str(color3[1]) + ',' + str(color3[2]) + ')') draw.stroke_width = math.ceil(initialPointsize / 10) - 1 # -------------------------------------------------------------- # ----------print word------------------------------------------ draw.fill_color = Color('rgb(' + str(color2[0]) + ',' + str(color2[1]) + ',' + str(color2[2]) + ')') draw.text(x=0, y=0, body=word) draw.draw(baseImage) # -------------------------------------------------------------- # ------------gray---------------------------------------------- baseImage.colorspace = 'gray' # -------------------------------------------------------------- print(word) baseImage.save(filename='./photo_en/' + str(count + 1) + '_' + word + '.jpg')
def resize_image(path=None, blob=None, img=None, name=None, fmt='jpeg', auto_orient=True, upscale=False): """A coroutine that resizes a single image multiple times Note that the same image buffer is used across multiple operations so operations should be ordered from highest-quality to lowest. Parameters: - path/blob/img: Source data (img is a Wand Image object) - name: The name of the file (for logging purposes only) - fmt: The image format of the resulting images (default: 'jpeg') - auto_orient: Automatically orient image before processing (default: true) - upscale: Upscale images to fit the desired resolution if they're too small (default: False) Receives a 4-tuple of (size, quality, square, fp) - size: The image will be resized so that the longest edge is this many pixels. If None the image will not be resized. - quality: The JPEG quality level - square: If true, the images will be cropped to square before being resized - fp: A file-like object to write() the result into """ if sum([bool(path), bool(blob), bool(img)]) != 1: raise ValueError("One of 'path', 'blob', or 'img' is required") if path: img = Image(filename=path) elif blob: img = Image(blob=blob) with img: # If there are multiple frames only use the first one (this # prevents GIFs and ICOs from exploding their frames into # individual images) if img.sequence: for _ in range(1, len(img.sequence)): img.sequence.pop() # Rotation and conversion to desired output format if auto_orient: img.auto_orient() img.format = fmt while True: size, quality, square, fp = yield __log__.debug("[resizing] %s -> %s%s", name or "<img data>", "{}px".format(size) if size else "fullsize", ", square" if square else "" ) if square: crop = min(img.size) img.crop(width=crop, height=crop, gravity='center') if size is not None and (upscale or size < crop): img.resize(size, size) elif size is not None: # Work around a bug in Wand's image transformation by # manually calculating the scaled dimensions and resizing ratio = size/max(img.size) if upscale or ratio < 1: img.resize(*[round(x*ratio) for x in img.size]) img.compression_quality = quality try: img.save(file=fp) except IOError as e: __log__.error("[error] Failed to write image: %s", e, exc_info=True) raise