def art_florp(bot,track_art): image = Image.open(track_art) image = image.filter(ImageFilter.FIND_EDGES) image = Image.blend(Image.blend(image, image.rotate(90), 0.5), Image.blend(image.rotate(180), image.rotate(270), 0.5), 0.5) new_track_art = track_art[:-3] + "rmx.florp." + track_art[-3:] image.save(new_track_art) return new_track_art
def process_ffx_loop():
frameSize = (256, 256)
gridSize = (8, 4)
totalFrames = gridSize[0] * gridSize[1]
offset = 4
outImageSize = (gridSize[0] * frameSize[0], gridSize[1] * frameSize[1])
outImage = Image.new('RGBA', outImageSize)
#alphaMultImage = Image.new('L', outImageSize)
x = 0
y = 0
for i in xrange(1, totalFrames + 1):
frameIdx = i + offset
frame = Image.open("C:/Projects/ffx/images/test2.{}.tga".format(str(frameIdx).zfill(4)))
frame.thumbnail(frameSize)
if i <= offset and False:
frameIdx2 = totalFrames + i
frame2 = Image.open("C:/Projects/ffx/images/test2.{}.tga".format(str(frameIdx2).zfill(4)))
frame2.thumbnail(frameSize)
_x = i
opacity = 0.5 + 0.5 * _x / float(offset + 0.5)
frame = Image.blend(frame2, frame, opacity)
elif i >= totalFrames - offset and False:
frameIdx2 = offset + 1 - (totalFrames - i)
frame2 = Image.open("C:/Projects/ffx/images/test2.{}.tga".format(str(frameIdx2).zfill(4)))
frame2.thumbnail(frameSize)
_x = totalFrames - i
opacity = 0.5 * (offset + 0.5 - _x) / float(offset + 0.5)
frame = Image.blend(frame, frame2, opacity)
#alphaMult = Image.open("C:/Projects/vfxutils/textures/alpha_mask.tga")
#alphaMult.thumbnail(frameSize)
location = (x * frameSize[0], y * frameSize[1])
outImage.paste(frame, location)
#alphaMultImage.paste(alphaMult, location)
x += 1
if x >= gridSize[0]:
x = 0
y += 1
# Make smooth borders
#r, g, b, a = outImage.split()
#a = ImageChops.multiply(a, alphaMultImage)
#outImage = Image.merge("RGBA", (r, g, b, a))
outImage.save("y:/art/source/particles/textures/special/ffx_loop_test.tga")
def octoflip(bot,art): image = Image.open(art) image = Image.blend(Image.blend(image, image.rotate(90), 0.5), Image.blend(image.rotate(180), image.rotate(270), 0.5), 0.5) image = Image.blend(image, image.rotate(45), 0.5) image = image.filter(ImageFilter.SHARPEN) image = image.filter(ImageFilter.SHARPEN) new_art = art[:-3] + "rmx.octo." + art[-3:] image.save(new_art) return new_art
def Calculate(image,coord): # image = image.rotate(180) # mean = Calculate_Color(image) base_image = MatchImage(image,'cartoon') ''' Cheating!merge image with original image ''' if coord in test_matrix2: result = Image.blend(base_image,image,0.85) else : result = Image.blend(base_image,image,0.75) return result
def cyan_glow(img):
glow = img.filter(ImageFilter.BLUR).filter(ImageFilter.BLUR)
glow = brightness(glow, 1.25)
result = Image.blend(overlay_blend(glow, img), img, 0.3)
# Tint Cyan
r = ImageChops.constant(img, 64)
g = ImageChops.constant(img, 255)
b = ImageChops.constant(img, 255)
cyan = Image.merge("RGB",(r,g,b))
result = Image.blend(overlay_blend(cyan, result), result, 0.8)
result = apply_vignette(result, 0.5)
return result
def to_png(in_path, page):
with tempfile.TemporaryDirectory() as workdir:
extension = in_path.split('.')[-1].lower()
if extension == 'brd':
layers = config.LAYERS.values()
out_paths = [ os.path.join(workdir, layer + '.png')
for layer in config.LAYERS.keys() ]
elif extension == 'sch':
layers = [{'layers': ['ALL']}]
out_paths = [os.path.join(workdir, 'all.png')]
else:
os.rmdir(workdir)
raise BadExtension
export = EaglePNGExport(workdir=workdir)
export.set_page(page)
export.export(in_path, layers, out_paths)
oim = None
for i, out_path in enumerate(out_paths):
im = Image.open(out_path).convert("L")
if oim is None:
oim = im
else:
oim = Image.blend(oim, im, 1.0/(1.0+i))
os.unlink(out_path)
workdir.cleanup()
return oim
def export_mask_blend(self, fn_img, rgb_img,alpha=0.6,plot_method="PIL",quality=60):
if alpha > 0.0:
mask_rgb = self.mask_rgb_array(dtype=np.uint8)
zoom_fac = np.array([s1 / s2 for s1,s2 in zip(rgb_img.shape,mask_rgb.shape)])
if (zoom_fac != [1.0,1.0,1.0]).all():
mask_rgb = zoom(input=mask_rgb,order=0,zoom=zoom_fac)
if plot_method == "PIL":
if alpha > 0.0:
img_rgb = Image.fromarray(rgb_img)
img_msk = Image.fromarray(mask_rgb)
img = Image.blend(img_rgb,img_msk,alpha)
img.save(fn_img,quality=quality)
else:
img_rgb = Image.fromarray(rgb_img)
img_rgb.save(fn_img,quality=quality)
elif plot_method == "mpl":
dpi = 100.0
fig = plt.figure(figsize=np.array(rgb_img.shape[:2]) / dpi)
plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
ax = plt.subplot()
# RGB image of scene as background
ax.imshow(rgb_img, interpolation="none")
# mask colors above, but transparent
ax.imshow(mask_rgb, interpolation="none", alpha=alpha)
ax.set_axis_off()
plt.savefig(fn_img, dpi=dpi)
fig.clear()
plt.close(fig)
else:
raise ValueError("Plot method: %s not implemented." % str(plot_method))
def diff_images(imagefile1, imagefile2, return_blocked1=False, tolerance=100):
'''
Parameters
----------
imagefile1, imagefile2 : images
Two images to compare. They should be the same size. Give by filename or with
raw data.
return_blocked1 : bool, default False
If true, also return an image `Elem` based on imagefile1 showing where the mismatch blocks are.
tolerance : int
This can be used as the sensitivity factor, the larger it is the less sensitive the comparison
Returns
-------
int
The number of mismatched blocks
Elem
optional, see return_blocked1
'''
screenshot_staging = Image.open(imagefile1)
screenshot_production = Image.open(imagefile2)
columns = 60
rows = 80
screen_width, screen_height = screenshot_staging.size
block_width = ((screen_width - 1) // columns) + 1 # this is just a division ceiling
block_height = ((screen_height - 1) // rows) + 1
mismatch_blocks = 0
if return_blocked1:
degenerate = Image.new(screenshot_staging.mode, screenshot_staging.size, '#FFFFFF')
if 'A' in screenshot_staging.getbands():
degenerate.putalpha(screenshot_staging.getchannel('A'))
screenshot_staging_1 = Image.blend(degenerate, screenshot_staging, 0.25)
for y in range(0, screen_height, block_height + 1):
for x in range(0, screen_width, block_width + 1):
region_staging = _process_region(screenshot_staging, x, y, block_width, block_height, tolerance=tolerance)
region_production = _process_region(screenshot_production, x, y, block_width, block_height, tolerance=tolerance)
if region_staging is not None and region_production is not None and region_production != region_staging:
mismatch_blocks += 1
if return_blocked1:
draw = ImageDraw.Draw(screenshot_staging_1)
draw.rectangle((x, y, x + block_width, y + block_height), outline="red")
if return_blocked1:
buffered = BytesIO()
screenshot_staging_1.save(buffered, format="PNG")
from xmle import Elem
blocked1 = Elem.from_png_raw(buffered.getvalue())
return mismatch_blocks, blocked1
return mismatch_blocks
def createImage(self):
self.setProgress(0)
# 파일 이름 걸러내기
self.filenames = list(filter(self.isValidFile, self.filenames))
self.row = (int)((len(self.filenames) + self.column - 1) / (self.column))
self.width = (int)(self.cellWidth * self.column + self.paddingX * 2)
self.height = (int)(self.cellHeight * self.row + self.paddingY * 2)
self.cw = (int)(self.width / self.nIter)
self.mergeImages()
interpolation = getattr(Image, self.interpolation)
mesh = self.createMesh(self.upperFunc, self.lowerFunc)
mirrorMesh = self.createMirrorMesh(self.upperFunc, self.lowerFunc)
img = self.mergedImage
result = img.transform(img.size, Image.MESH, mesh, interpolation)
self.setProgress(61)
blank = Image.new("RGBA", (self.width, self.height))
reflect = img.copy()
reflect = img.transpose(Image.FLIP_TOP_BOTTOM)
self.setProgress(81)
reflect = reflect.transform(img.size, Image.MESH, mirrorMesh, interpolation)
self.setProgress(92)
reflect = Image.blend(reflect, blank, 0.5)
y = int(self.paddingY * 2.9)
result.paste(reflect, (0, self.height - y,
self.width, self.height * 2 - y), reflect)
self.setProgress(100)
self.result = result
def process_imgs(self, f0, f1, ctr=0):
im0 = f0
im1 = f1
im_ctr = ctr
out_file = self.o_path + "img"
# for level in range(20):
# out_file_curr = out_file+utils.zero_str(4,im_ctr)+self.o_type
# im0.save(out_file_curr)
# im_ctr +=1
transition = self.warp_frames / 2
transition_start = self.warp_frames / 4
transition_end = self.warp_frames - self.warp_frames / 4
for level in range(int(self.warp_frames) + 1):
out_file_curr = out_file + utils.zero_str(4, im_ctr) + self.o_type
# if level< 10:
# im0.save(out_file_curr)
# elif level>self.warp_frames-10:
# im1.save(out_file_curr)
# else:
if level < transition_start:
alpha = 0
elif level > transition_end:
alpha = 1
else:
alpha = float(level - transition_start) / float(self.warp_frames + 1 - transition)
im_new = Image.blend(im0, im1, alpha)
###### TODO HACK FOR 2000x1333 image
im_new = im_new.crop((40, 120, 1960, 1200))
# im_new=im_new.resize((1920,1080),Image.BILINEAR)
im_new.save(out_file_curr)
im_ctr += 1
def update(self):
if self.health!=self.healthmax:
if self.health<0:
self.health=0
if self.health<self.healthmax:
t=time.time()
if globalconst.DEBUG:
print t-self.restTime
if (t-self.restTime)>60:
self.health+=self.spirit+self.strength
if self.health>self.healthmax:
self.health=self.healthmax
self.restTime=t
alpha=(float)(self.healthmax-self.health)/self.healthmax
image=Image.blend(self.PILimage, self.PILdyingimg,alpha )
#drawing the health bar ... could be something like a function or an ineherit attribut of abstract class for all objet with life ...
beginPixelHealth=alpha*image.size[0]
beginPixelHealth=(int) (beginPixelHealth)
boxhealth=(0,0,image.size[0]-beginPixelHealth,2)
healthbar=Image.new('RGB',(image.size[0]-beginPixelHealth,2),(0,255,0))
image.paste(healthbar,boxhealth)
image=image.convert('RGBA')
imgstr=image.tostring()
self.image=pygame.image.fromstring(imgstr,image.size,'RGBA')
if self.health<=0:
for killer in self.killer:
for obj in self.objectofthescene_group:
if hasattr(obj,"name"):
if obj.name==killer:
obj.xpup(self.lvl)
self.kill()
def __init__(self, master, func):
Tkinter.Toplevel.__init__(self, master, relief=Tkinter.SOLID, highlightthickness=1, highlightcolor=fg)
self.root = master
self.root.withdraw()
self.overrideredirect(Tkinter.TRUE)
self.progress = Progressbar(self)
if not config.python3:
self.image1 = Image.open(config.relinuxdir + "/splash.png")
self.image2 = Image.open(config.relinuxdir + "/splash_glowy.png")
self.images = []
for i in range(0, 11):
percent = float(float(i) / 10)
self.images.append(ImageTk.PhotoImage(Image.blend(self.image1, self.image2, percent)))
# self.image = ImageTk.PhotoImage(Image.blend(self.image1, self.image2, 0.0))
self.image = self.images[0]
self.imgw = self.image.width()
self.imgh = self.image.height()
else:
self.image = Tkinter.PhotoImage(file=config.relinuxdir + "/splash.ppm")
self.imgw = self.image.width()
self.imgh = self.image.height()
self.textvar = Tkinter.StringVar()
self.progresstext = Label(self, textvariable=self.textvar, height=15, width=480, anchor=Tkinter.W)
self.w = self.imgw
self.h = self.imgh + 32
self.x = self.root.winfo_screenwidth() / 2 - self.w / 2
self.y = self.root.winfo_screenheight() / 2 - self.h / 2
self.geometry("%dx%d+%d+%d" % (self.w, self.h, self.x, self.y))
self.panel = Label(self, image=self.image)
self.panel.pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=True)
self.progress.pack(side=Tkinter.BOTTOM, fill=Tkinter.X, expand=True)
self.progresstext.pack(side=Tkinter.BOTTOM, fill=Tkinter.X, expand=True)
self.update()
self.thread = FuncThread(func, self.endSplash, self)
self.thread.start()
def set_background(self):
img_file = "/tmp/root_window.jpg"
w = gtk.gdk.get_default_root_window()
sz = w.get_size()
pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,sz[0],sz[1])
pb = pb.get_from_drawable(w,w.get_colormap(),0,0,0,0,sz[0],sz[1])
if (pb != None):
pb.save(img_file,"jpeg")
image = Image.open(img_file)
color = 'black'
alpha = 0.5
mask = Image.new("RGB", image.size, color)
image = Image.blend(image, mask, alpha)
image.save(img_file,"jpeg")
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(img_file, self.screen_x, self.screen_y)
pixmap, mask = pixbuf.render_pixmap_and_mask()
# width, height = pixmap.get_size()
self.window.set_app_paintable(True)
self.window.resize(self.screen_x, self.screen_y)
self.window.realize()
self.window.window.set_back_pixmap(pixmap, False)
self.window.move(0,0)
del pixbuf
del pixmap
def blend_images(data_folder1, data_folder2, out_folder, alpha=.5):
filename_queue = tf.placeholder(dtype=tf.string)
label = tf.placeholder(dtype=tf.int32)
tensor_image = tf.read_file(filename_queue)
image = tf.image.decode_jpeg(tensor_image, channels=3)
multiplier = tf.div(tf.constant(224, tf.float32),
tf.cast(tf.maximum(tf.shape(image)[0], tf.shape(image)[1]), tf.float32))
x = tf.cast(tf.round(tf.mul(tf.cast(tf.shape(image)[0], tf.float32), multiplier)), tf.int32)
y = tf.cast(tf.round(tf.mul(tf.cast(tf.shape(image)[1], tf.float32), multiplier)), tf.int32)
image = tf.image.resize_images(image, [x, y])
image = tf.image.rot90(image, k=label)
image = tf.image.resize_image_with_crop_or_pad(image, 224, 224)
sess = tf.Session()
sess.run(tf.local_variables_initializer())
for root, folders, files in os.walk(data_folder1):
for each in files:
if each.find('.jpg') >= 0:
img1 = Image.open(os.path.join(root, each))
img2_path = os.path.join(root.replace(data_folder1, data_folder2), each.split("-")[-1])
rotation = int(each.split("-")[1])
img2 = sess.run(image, feed_dict={filename_queue: img2_path, label: rotation})
imsave(os.path.join(os.getcwd(), "temp", "temp.jpg"), img2)
img2 = Image.open(os.path.join(os.getcwd(), "temp", "temp.jpg"))
out_image = Image.blend(img1, img2, alpha)
outfile = os.path.join(root.replace(data_folder1, out_folder), each)
if not os.path.exists(os.path.split(outfile)[0]):
os.makedirs(os.path.split(outfile)[0])
out_image.save(outfile)
else:
print(each)
sess.close()
def WorkBook_plotPrisons(self, coords):
lons = coords[0]
lats = coords[1]
print("Graphing image...")
m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-64,
urcrnrlat=49, projection='lcc', lat_1=33, lat_2=45,
lon_0=-95, resolution='h', area_thresh=10000)
x, y = m(lons, lats)
m.drawmapboundary(fill_color='white')
m.fillcontinents(color='white',lake_color='white')
m.scatter(x,y,10,marker='D',color='m')
plt.figure(frameon=False)
plt.title('US Prison Locations',fontsize=12)
plt.savefig("USPrisons.png")
background = Image.open("SocioEconomicBackground.png")
overlay = Image.open("USPrisons.png")
background = background.convert("RGBA")
overlay = overlay.convert("RGBA")
new_img = Image.blend(background, overlay, 0.5)
new_img.save("SocioEconomic_Prison.png","PNG")
def get_hdr(self, images, strength=0.0, naturalness=1.0):
"""
process the hdr image(s)
strength - a float that defines how strong the hdr
effect should be
- a value of zero will combine images by using a
greyscale image average
- a value greater than zero will use higher contrast
versions of those greyscale images
- suggest you a value between 0.0 and 2.0
naturalness - values between zero and one
- zero will be a very high-contrast image
- 1.0 will be a very flat image
- 0.7 to 0.9 tend to give the best results
"""
imgs = copy([Image.fromarray(img) for img in images])
sat_img = self.merge_all(imgs, strength)
if self.debug_show.get_pos_list() == 1:
return np.array(sat_img)
imgs.reverse()
con_img = self.merge_all(imgs, strength)
if self.debug_show.get_pos_list() == 2:
return np.array(con_img)
"""
combines a saturated image with a contrast image
and puts them in a dictionary of completed images
"""
images = Image.blend(con_img, sat_img, naturalness)
images = np.array(images)
return images
def changeImage(slice_num):
global PreViewImage, PreviewName, stlfilename
global image_tk
PreviewName.set("Preview Images - "+stlfilename[:-4]+str(slice_num)+".png")
OperationValue = OperationVar.get()
imageBlank = Image.new("RGB", (768,480),0)
image_im_m1 = imageBlank
if (OperationValue == 1):
imageFile = FileputPath+stlfilename[:-4]+str(int(slice_num)) +".png"
try:
image_im = Image.open(imageFile)
except:
print imageFile+" error"
showinfo("Error:", imageFile+" Open Error!")
#checkslice_ui.destroy()
return
if (OperationValue == 2):
imageFile = FileputPath+stlfilename[:-4]+str(int(slice_num)) +".png"
try:
image_im = Image.open(imageFile)
except:
print imageFile+" error"
showinfo("Error:", imageFile+" Open Error!")
#checkslice_ui.destroy()
return
imageFilem1 = FileputPath+stlfilename[:-4]+str(int(slice_num)-1)+".png"
try:
image_im_m1 = Image.open(imageFilem1)
except:
image_im_m1 = imageBlank
image_im = image_im.convert("L")
image_im = ImageOps.colorize(image_im, (0,0,0), (255,0,0))
image_im = image_im.convert("RGB")
image_im_m1 = image_im_m1.convert("L")
image_im_m1 = ImageOps.colorize(image_im_m1, (0,0,0), (255,255,255))
image_im_m1 = image_im_m1.convert("RGB")
try:
image_im = Image.blend(image_im, image_im_m1, 0.3)
except:
null()
image_im_enhance = ImageEnhance.Brightness(image_im)
image_im = image_im_enhance.enhance(2.0)
image_tk = ImageTk.PhotoImage(image_im)
PreViewImage.configure(image = image_tk)
return
def blend(im1, im2, amount, color=None):
"""Blend two images with each other. If the images differ in size
the color will be used for undefined pixels.
:param im1: first image
:type im1: pil.Image
:param im2: second image
:type im2: pil.Image
:param amount: amount of blending
:type amount: int
:param color: color of undefined pixels
:type color: tuple
:returns: blended image
:rtype: pil.Image
"""
im2 = convert_safe_mode(im2)
if im1.size == im2.size:
im1 = convert(im1, im2.mode)
else:
if color is None:
expanded = Image.new(im2.mode, im2.size)
elif im2.mode in ('1', 'L') and type(color) != int:
expanded = Image.new(im2.mode, im2.size, color[0])
else:
expanded = Image.new(im2.mode, im2.size, color)
im1 = im1.convert(expanded.mode)
we, he = expanded.size
wi, hi = im1.size
paste(expanded, im1, ((we - wi) / 2, (he - hi) / 2),
im1.convert('RGBA'))
im1 = expanded
return Image.blend(im1, im2, amount)
def do_I_have_to_draw_you_a_picture(self):
""" Return a little thumbs-up / thumbs-down image with text in it.
"""
if self.success:
bytes, color = _thumbs_up_bytes, _thumbs_up_color
else:
bytes, color = _thumbs_down_bytes, _thumbs_down_color
thumb = Image.open(StringIO(bytes))
image = Image.new('RGB', (256, 256), color)
image.paste(thumb.resize((128, 128)), (64, 80))
mapnik_url = 'http://tile.openstreetmap.org/%(zoom)d/%(column)d/%(row)d.png' % self.coord.__dict__
mapnik_img = Image.open(StringIO(urlopen(mapnik_url).read()))
mapnik_img = mapnik_img.convert('L').convert('RGB')
image = Image.blend(image, mapnik_img, .15)
draw = ImageDraw(image)
margin, leading = 8, 12
x, y = margin, margin
for word in self.content.split():
w, h = draw.textsize(word)
if x > margin and x + w > 250:
x, y = margin, y + leading
draw.text((x, y), word, fill=(0x33, 0x33, 0x33))
x += draw.textsize(word + ' ')[0]
return image
def _get_image(overlay, x, y):
"""Superpose the picture of the timezone on the map"""
def _get_x_offset():
now = datetime.utcnow().timetuple()
return - int((now.tm_hour * 60 + now.tm_min - 12 * 60) / (24 * 60) * MAP_SIZE[0]) # night is centered at UTC noon (12)
im = BACK_IM.copy()
if overlay:
overlay_im = Image.open(TIMEZONE_RESOURCES + overlay)
im.paste(BACK_ENHANCED_IM, overlay_im)
night_im = ImageChops.offset(NIGHT_IM, _get_x_offset(), 0).crop(im.getbbox())
if IS_WINTER:
night_im = ImageOps.flip(night_im)
# In Wheezy alpha_composite and tobytes are not implemented, yet
try:
im.paste(Image.alpha_composite(night_im, LIGHTS_IM), night_im)
except:
im.paste(Image.blend(night_im, LIGHTS_IM, 0.5), night_im)
im.paste(DOT_IM, (int(x - DOT_IM.size[1] / 2), int(y - DOT_IM.size[0] / 2)), DOT_IM)
try:
data = im.tobytes()
w, h = im.size
data = GLib.Bytes.new(data)
pb = GdkPixbuf.Pixbuf.new_from_bytes(data, GdkPixbuf.Colorspace.RGB,
False, 8, w, h, w * 3)
return pb
except:
data = im.tostring()
w, h = im.size
pb = GdkPixbuf.Pixbuf.new_from_data(barr, GdkPixbuf.Colorspace.RGB,
False, 8, w, h, w * 3)
return pb
def space(image):
image = image.convert('RGB')
colours = util.get_dominant_colours(image, 12)
colours = util.order_colours_by_brightness(colours)
indices = sorted(random.sample(range(len(colours)), 3))
colours = [colours[i] for i in indices]
light, bg, dark = map(tuple, colours)
light = (200, 200, 100)
dark = (100, 200, 100)
bg = (0, 0, 50, 255)
layer = Image.open(os.path.dirname(os.path.abspath(__file__)) + '/' +
'assets/space.jpg')
layer = util.random_crop(layer, util.WIDTH, util.HEIGHT)
colours = util.get_dominant_colours(image, 10)
colours = util.order_colours_by_saturation(colours)[:-3]
colours = random.sample(colours, 5)
colours = util.order_colours_by_hue(colours)
layer = layer.convert('RGB')
gradient = util.create_gradient(layer.size, colours)
im = Image.blend(layer, gradient, .4)
return im
def blending(im, alpha):
dir_from = '..\\blending'
blending_im_list = os.listdir(dir_from)
while(True):
blending_im_name = blending_im_list[random.randint(0, len(blending_im_list)-1)]
if(blending_im_name.endswith('.db') == True): #跳过缓存文件
continue
blending_im = Image.open(dir_from + '\\' + blending_im_name, mode = 'r')
break
if(min(blending_im.size) < IM_SIZE):
blending_im = blending_im.crop((0, 0, min(blending_im.size), min(blending_im.size)))
blending_im = blending_im.resize((IM_SIZE, IM_SIZE))
else:
horizontal_pos = random.randint(0, blending_im.size[0] - IM_SIZE - 1)
vertical_pos = random.randint(0, blending_im.size[1] - IM_SIZE - 1)
blending_im = blending_im.crop((horizontal_pos, vertical_pos, horizontal_pos + IM_SIZE, vertical_pos + IM_SIZE))
im.save('tmp.png', "PNG")
im2 = Image.open('tmp.png', mode = 'r')
im2 = im2.convert("RGBA")
blending_im = blending_im.convert("RGBA")
im3 = Image.blend(im2, blending_im, alpha)
return im3
def transition(path_wall, wallpapers, size, step, trans_step):
"""
overlay two following images from the wallpapers list, save them and
write the new overlay to the next list
"""
from PIL import Image
key = checkRun(path_wall)
if key is True:
## for a clean picture folder, all unvisible images will be stored in here
path_trans = path_wall + ".PyNit_trash/"
if not os.path.isdir(path_trans):
os.mkdir(path_trans)
## shuffle the wallpaper list in place
random.shuffle(wallpapers)
for i in range(len(wallpapers)-1):
old_pic = wallpapers[i]
new_pic = wallpapers[i+1]
background = Image.open(path_wall + old_pic)
overlay = Image.open(path_wall + new_pic)
## check if both pictures have desired size
## a dummy is produced there will be no harm done to your pictures
if background.size != size:
background = resize(size, background)
background.save(path_trans + "dummy_background.jpg","JPEG")
background = Image.open(path_trans + "dummy_background.jpg")
if overlay.size != size:
overlay = resize(size, overlay)
overlay.save(path_trans + "dummy_overlay.jpg","JPEG")
overlay = Image.open(path_trans + "dummy_overlay.jpg")
background = background.convert("RGBA")
overlay = overlay.convert("RGBA")
new_img_lst = []
for k in range(0, trans_step, 1):
new_img = Image.blend(background, overlay, (k/trans_step))
new_img.save(path_trans + "new" + str(k) + ".jpg","JPEG")
new_img_lst.append("new" + str(k) + ".jpg")
for transit_pic in new_img_lst:
## just a reminder: "-a" uses the wallpaper path
os.system("PyNit.py -a " + ".PyNit_trash/" + transit_pic)
## end loop with 100% of the new pic
os.system("PyNit.py -a " + new_pic)
## rest STEP seconds
time.sleep(step)
if i == len(wallpapers)-1:
## if end of shuffled list is reached shuffle again
random.shuffle(wallpapers)
else:
continue
def renderCollage(solution, grid, sampleGrid, imageLibrary, outputFile, cheatFactor=0):
"""Post-optimizes the solution and renders the output."""
logger.info("Post-optimizing ...")
optimalParameters = {}
for i in range(grid.imageCountX):
logger.progress(i, grid.imageCountX)
for j in range(grid.imageCountY):
imageIndex = solution[i, j]
image = imageLibrary.images[imageIndex]
sampleImage = image.get(sampleGrid.imageWidth, sampleGrid.imageHeight).get()
optimalParameters[i, j] = postOptimize(sampleImage, sampleGrid[i, j].get())
logger.info("Rendering collage ...")
background = Image.new("RGB", grid.size, "white")
collage = Image.new("RGB", grid.size, "white")
for i in range(grid.imageCountX):
logger.progress(i, grid.imageCountX)
for j in range(grid.imageCountY):
offset = (i * grid.imageWidth, j * grid.imageHeight)
imageIndex = solution[i, j]
image = imageLibrary.images[imageIndex]
subImage = image.get(grid.imageWidth, grid.imageHeight).get()
image = adjustImage(subImage, optimalParameters[i, j])
background.paste(grid[i, j].get(), offset)
collage.paste(image, offset)
logger.info("Saving ...")
output = Image.blend(collage, background, cheatFactor)
output.save(outputFile)
def draw_ellipse_to_file(jpgfile, imgarray, major, minor, angle, center=None,
numpoints=64, color="#3d3df2", width=4):
"""
major - major axis radius (in pixels)
minor - minor axis radius (in pixels)
angle - angle (in degrees)
center - position of centre of ellipse
numpoints - # of points used that make an ellipse
angle is positive toward y-axis
"""
if center is None:
center = numpy.array(imgarray.shape, dtype=numpy.float)/2.0
points = ellipse.generate_ellipse(major, minor, angle, center, numpoints, None, "step", True)
x = points[:,0]
y = points[:,1]
## wrap around to end
x = numpy.hstack((x, [x[0],]))
y = numpy.hstack((y, [y[0],]))
## convert image
originalimage = imagefile.arrayToImage(imgarray)
originalimage = originalimage.convert("RGB")
pilimage = originalimage.copy()
draw = ImageDraw.Draw(pilimage)
for i in range(len(x)-1):
xy = (x[i], y[i], x[i+1], y[i+1])
draw.line(xy, fill=color, width=width)
## create an alpha blend effect
originalimage = Image.blend(originalimage, pilimage, 0.9)
originalimage.save(jpgfile, "JPEG", quality=85)
return
def _overlay(self, im0, im1, alpha):
try:
arr = Image.blend(im1, im0, alpha)
self.source_frame = asarray(arr)
self.refresh_needed = True
except ValueError:
pass
def marksimilar(image, clust, size):
"""
Draw discovered similar image regions.
"""
global opt
blocks = []
if clust:
draw = ImageDraw.Draw(image)
mask = Image.new('RGB', (size,size), 'cyan')
for cl in clust:
for x,y in cl:
im = image.crop((x,y,x+size,y+size))
im = Image.blend(im,mask,0.5)
blocks.append((x,y,im))
for bl in blocks:
x,y,im = bl
image.paste(im,(x,y,x+size,y+size))
if int(opt.imauto):
for cl in clust:
cx1 = min([cx for cx,cy in cl])
cy1 = min([cy for cx,cy in cl])
cx2 = max([cx for cx,cy in cl]) + block_len
cy2 = max([cy for cx,cy in cl]) + block_len
draw.rectangle([cx1,cy1,cx2,cy2],outline="magenta")
return image
def filter_blend(image, baseDir, *args):
if len(args) == 2:
filename, opacity = args
overlay = load_image(os.path.join(
baseDir,
*filename.split('/')
))
else:
red, green, blue, opacity = args
overlay = Image.new('RGB', image.size, (
int(red),
int(green),
int(blue),
))
# if the background image has an alpha channel copy it to
# the overlay, so that transparent areas stay transparent.
alpha = get_alpha(image)
if alpha:
overlay.putalpha(alpha)
image, overlay = ensure_same_mode(image, overlay)
return Image.blend(image, overlay, float(opacity))
def handle_btn(self):
if self.current_image_index + 1 < len(self.sortedoriginal):
self.current_image_index = self.current_image_index + 1
#Set new original image
self.current_original_image = QPixmap(os.path.join(self.original_path, self.sortedoriginal[self.current_image_index]))
self.origim = Image.open(os.path.join(self.original_path, self.sortedoriginal[self.current_image_index]))
self.origimresized = resizeimage.resize_cover(self.origim, [1003, 752])
self.b.setPixmap(self.current_original_image)
self.b.setPixmap(self.current_original_image.scaledToWidth(1003))
self.w.setWindowTitle("Original image: " + self.sortedoriginal[self.current_image_index])
#set new mask image
self.current_mask = QPixmap(os.path.join(self.full_masks_path, self.sortedmasks[self.current_image_index]))
self.maskim = Image.open(os.path.join(self.full_masks_path, self.sortedmasks[self.current_image_index]))
self.b2.setPixmap(self.current_mask)
self.w2.setWindowTitle("Full mask: " + self.sortedmasks[self.current_image_index])
#set new overlay image
self.overlayed_image = Image.blend(self.origimresized, self.maskim, 0.3)
self.qim = ImageQt(self.overlayed_image)
self.pix = QPixmap.fromImage(self.qim)
self.b3.setPixmap(self.pix)
self.w3.setWindowTitle('Overlayed Image: ' + self.sortedoriginal[self.current_image_index])
self.w3.show()
else:
print("No more images in directory!")
def compare_graphs(img1, img2, alpha = 0.3): # img1 = 'fig_sales_price.png' background = Image.open(img1) foreground = Image.open(img2) out = Image.blend(background, foreground, alpha) out.show()
test_images = image.img_to_array(img).astype('float32') / 255
test_images = np.reshape(test_images, (1, 224, 224, 3))
# network
def build_network():
base_model = inception_v3.InceptionV3(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
base_model2 = models.Model(inputs=base_model.input, outputs=base_model.get_layer('mixed10').output)
x = layers.GlobalAveragePooling2D()(base_model2.output)
x = layers.Dense(128, activation='relu')(x)
output_amdState = layers.Dense(2, activation='sigmoid', name='output_amdState')(x)
x = layers.Dense(4, activation='relu')(output_amdState)
output_time = layers.Dense(1, activation='sigmoid', name='output_time')(x)
model = models.Model(inputs=base_model2.input, outputs=[output_amdState, output_time])
opt = optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['acc'])
return model
model = build_network()
model.load_weights(options.weights + "/analysis_cat" + options.cutoff_yr + "/model_finetune_img2amdState2time.h5")
mapp = visualize_saliency(model, -1, 0, test_images[0])
background = test_images[0]
background = Image.fromarray((background*255).astype('uint8'), 'RGB')
overlay = Image.fromarray((mapp*255).astype('uint8'), 'RGB')
background = background.convert("RGBA")
overlay = overlay.convert("RGBA")
new_img = Image.blend(background, overlay, 0.5)
fig = plt.figure(1)
plt.imshow(new_img)
fig.savefig(options.out_image)
def wipeexec(self, canvasdata, type, speed, option):
speed = float(speed)
if type == "randomfade":
listarray = ["crossfade", "tile"]
type = listarray[random.randrange(len(listarray))]
elif type == "random":
listarray = ["crossfade", "tile", "tinytile", "slide", "slideh"]
type = listarray[random.randrange(len(listarray))]
if type == "crossfade":
speed = speed / 50
for i in range(50):
j = i + 1
j = float(1) / float(50) * float(j)
self.crosscanvas = Image.blend(self.ledcanvasprev, canvasdata,
j)
self.ledoutput(self.crosscanvas)
time.sleep(speed)
elif type == "tile":
speed = speed / 32
masktilebase = Image.new("L", (8, 40), 0)
draw = ImageDraw.Draw(masktilebase)
draw.rectangle((0, 32, 7, 39), fill=(255), outline=(255))
for i in range(24):
j = i + 8
k = int(float(255) / float(24) * float(j))
draw.rectangle((0, j, 7, j), fill=k, outline=k)
for i in range(32):
mask = Image.new("L", (canvasdata.width, canvasdata.height), 0)
masktile = Image.new("L", (16, 32), 0)
j = i + 8
masktilebase_crop = masktilebase.crop((0, i, 8, j))
masktile.paste(masktilebase_crop, (0, 0))
masktilebase_crop = ImageOps.flip(masktilebase_crop)
masktile.paste(masktilebase_crop, (8, 0))
for k in range(4):
l = k * 8
masktile.paste(masktile, (0, l))
for k in range(8):
l = k * 16
mask.paste(masktile, (l, 0))
self.crosscanvas = Image.composite(canvasdata,
self.ledcanvasprev, mask)
self.ledoutput(self.crosscanvas)
time.sleep(speed)
elif type == "tinytile":
speed = speed / 8
for i in range(8):
j = i + 1
mask = Image.new("L", canvasdata.size, 0)
masktile = Image.new("L", (16, 32), 0)
draw = ImageDraw.Draw(masktile)
draw.rectangle((0, 0, 7, j), fill=(255), outline=(255))
j = 8 - j
draw.rectangle((8, 7, 15, j), fill=(255), outline=(255))
for k in range(4):
l = k * 8
masktile.paste(masktile, (0, l))
for k in range(8):
l = k * 16
mask.paste(masktile, (l, 0))
self.crosscanvas = Image.composite(canvasdata,
self.ledcanvasprev, mask)
self.ledoutput(self.crosscanvas)
time.sleep(speed)
elif type == "slide":
speed = speed / self.ledoptions_cols
canvasmaskbase = Image.new(
'RGB', ((int(self.ledoptions_cols) * 2), self.ledoptions_rows),
(0, 0, 0))
canvasmaskbase.paste(self.ledcanvasprev, (0, 0))
canvasmaskbase.paste(canvasdata, (self.ledoptions_cols, 0))
for i in range(self.ledoptions_cols):
cropx = i + self.ledoptions_cols
self.crosscanvas = canvasmaskbase.crop(
(i, 0, cropx, (int(self.ledoptions_rows))))
self.ledoutput(self.crosscanvas)
time.sleep(speed)
elif type == "slideh":
speed = speed / self.ledoptions_rows
canvasmaskbase = Image.new('RGB',
(self.ledoptions_cols,
(int(self.ledoptions_rows) * 2)),
(0, 0, 0))
canvasmaskbase.paste(self.ledcanvasprev, (0, 0))
canvasmaskbase.paste(canvasdata, (0, self.ledoptions_rows))
for i in range(self.ledoptions_rows):
cropy = i + self.ledoptions_rows
self.crosscanvas = canvasmaskbase.crop(
(0, i, (int(self.ledoptions_cols)), cropy))
self.ledoutput(self.crosscanvas)
time.sleep(speed)
else:
self.ledoutput(canvasdata)
self.ledoutput(canvasdata)
self.ledcanvasprev = copy.copy(canvasdata)
imgs = os.listdir("img")
for jpg in imgs:
img = Image.open("img/" + jpg)
old_img = copy.deepcopy(img)
orininal_h = np.array(img).shape[0]
orininal_w = np.array(img).shape[1]
img = img.resize((WIDTH, HEIGHT))
img = np.array(img)
img = img / 255
img = img.reshape(-1, HEIGHT, WIDTH, 3)
pr = model.predict(img)[0]
pr = pr.reshape(
(int(HEIGHT / 2), int(WIDTH / 2), NCLASSES)).argmax(axis=-1)
seg_img = np.zeros((int(HEIGHT / 2), int(WIDTH / 2), 3))
colors = class_colors
for c in range(NCLASSES):
seg_img[:, :, 0] += ((pr[:, :] == c) * (colors[c][0])).astype('uint8')
seg_img[:, :, 1] += ((pr[:, :] == c) * (colors[c][1])).astype('uint8')
seg_img[:, :, 2] += ((pr[:, :] == c) * (colors[c][2])).astype('uint8')
seg_img = Image.fromarray(np.uint8(seg_img)).resize(
(orininal_w, orininal_h))
image = Image.blend(old_img, seg_img, 0.3)
image.save("img_out" + jpg)
def segmentChamber(videofile, dicomdir, view):
mean = 24
weight_decay = 1e-12
learning_rate = 1e-4
maxout = False
sesses = []
models = []
if view == "a4c":
g_1 = tf.Graph()
with g_1.as_default():
label_dim = 6 #a4c
sess1 = tf.Session()
model1 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess1.run(tf.local_variables_initializer())
sess = sess1
model = model1
with g_1.as_default():
saver = tf.train.Saver()
saver.restore(sess1, './models/a4c_45_20_all_model.ckpt-9000')
elif view == "a2c":
g_2 = tf.Graph()
with g_2.as_default():
label_dim = 4
sess2 = tf.Session()
model2 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess2.run(tf.local_variables_initializer())
sess = sess2
model = model2
with g_2.as_default():
saver = tf.train.Saver()
saver.restore(sess2, './models/a2c_45_20_all_model.ckpt-10600')
elif view == "a3c":
g_3 = tf.Graph()
with g_3.as_default():
label_dim = 4
sess3 = tf.Session()
model3 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess3.run(tf.local_variables_initializer())
sess = sess3
model = model3
with g_3.as_default():
saver.restore(sess3, './models/a3c_45_20_all_model.ckpt-10500')
elif view == "psax":
g_4 = tf.Graph()
with g_4.as_default():
label_dim = 4
sess4 = tf.Session()
model4 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess4.run(tf.local_variables_initializer())
sess = sess4
model = model4
with g_4.as_default():
saver = tf.train.Saver()
saver.restore(sess4, './models/psax_45_20_all_model.ckpt-9300')
elif view == "plax":
g_5 = tf.Graph()
with g_5.as_default():
label_dim = 7
sess5 = tf.Session()
model5 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess5.run(tf.local_variables_initializer())
sess = sess5
model = model5
with g_5.as_default():
saver = tf.train.Saver()
saver.restore(sess5, './models/plax_45_20_all_model.ckpt-9600')
outpath = "./segment/" + view + "/"
if not os.path.exists(outpath):
os.makedirs(outpath)
framedict = create_imgdict_from_dicom(dicomdir, videofile)
images, orig_images = extract_images(framedict)
if view == "a4c":
a4c_lv_segs, a4c_la_segs, a4c_lvo_segs, preds = extract_segs(
images, orig_images, model, sess, 2, 4, 1)
np.save(outpath + '/' + videofile + '_lv',
np.array(a4c_lv_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_la',
np.array(a4c_la_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_lvo',
np.array(a4c_lvo_segs).astype('uint8'))
elif view == "a2c":
a2c_lv_segs, a2c_la_segs, a2c_lvo_segs, preds = extract_segs(
images, orig_images, model, sess, 2, 3, 1)
np.save(outpath + '/' + videofile + '_lv',
np.array(a2c_lv_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_la',
np.array(a2c_la_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_lvo',
np.array(a2c_lvo_segs).astype('uint8'))
elif view == "psax":
psax_lv_segs, psax_lvo_segs, psax_rv_segs, preds = extract_segs(
images, orig_images, model, sess, 2, 1, 3)
np.save(outpath + '/' + videofile + '_lv',
np.array(psax_lv_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_lvo',
np.array(psax_lvo_segs).astype('uint8'))
elif view == "a3c":
a3c_lv_segs, a3c_la_segs, a3c_lvo_segs, preds = extract_segs(
images, orig_images, model, sess, 2, 3, 1)
np.save(outpath + '/' + videofile + '_lvo',
np.array(a3c_lvo_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_lv',
np.array(a3c_lv_segs).astype('uint8'))
np.save(outpath + '/' + videofile + '_la',
np.array(a3c_la_segs).astype('uint8'))
elif view == "plax":
plax_lv_inter_ventricular_segs, preds = extract_segs(
images, orig_images, model, sess, 2)
np.save(outpath + '/' + videofile + '_lv_inter_ventricular_G2',
np.array(plax_lv_inter_ventricular_segs).astype('uint8'))
j = 0
nrow = orig_images[0].shape[0]
ncol = orig_images[0].shape[1]
print(nrow, ncol)
plt.figure(figsize=(25, 25))
plt.axis('off')
plt.imshow(imresize(preds, (nrow, ncol)))
plt.savefig(outpath + '/' + videofile + '_' + str(j) + '_' +
'CHOICE_FULL_segmentation_IVS.png')
plt.close()
plt.figure(figsize=(25, 25))
plt.axis('off')
plt.imshow(orig_images[0])
plt.savefig(outpath + '/' + videofile + '_' + str(j) + '_' +
'CHOICE_FULL_original_IVS.png')
plt.close()
background = Image.open(outpath + '/' + videofile + '_' + str(j) + '_' +
'CHOICE_FULL_original_IVS.png')
overlay = Image.open(outpath + '/' + videofile + '_' + str(j) + '_' +
'CHOICE_FULL_segmentation_IVS.png')
background = background.convert("RGBA")
overlay = overlay.convert("RGBA")
outImage = Image.blend(background, overlay, 0.5)
outImage.save(
outpath + '/' + videofile + '_' + str(j) + '_' +
'CHOICE_FULL_overlay_IVS.png', "PNG")
return 1
hspace=0,
wspace=0)
plt.margins(0, 0)
plt.savefig(path + 'tmp.png',
transparent=False,
bbox_inches='tight',
pad_inches=0)
# 2 Bilder überlappen
img1 = Image.open(path + filename_1)
img1 = img1.convert('RGBA')
img2 = Image.open(path + 'tmp.png')
img2 = img2.convert('RGBA')
img = Image.blend(img1, img2, 0.3)
# img.show()
filename_1 = filename_1.split('.')[0] + '_Gradient.png'
img.save(path + filename_1)
new_name = filename_1.split('.')[0] + '.txt'
newfile_path = os.path.join(path, new_name)
shutil.copyfile(file_path, newfile_path)
os.remove(path + 'tmp.png')
# print(np.array(Image.open(path + filename)).shape)
# Defokus, Blur
random_2 = np.random.uniform(0, 10)
if random_2 <= 6:
# filename_defokus = filename_1.split('.')[0] + '_Gradient.png' + '_Defokus.png'
def greenTint(im):
'''green tinted image'''
layer = Image.new('RGB', im.size, 'green')
return Image.blend(im, layer, 0.5)
# Take two images for blending them together
path = '../../data/geoPose3K/eth_ch1_2011-10-04_14_25_54_01024'
image1 = Image.open(join(path, "photo.jpg"))
image2 = Image.open(join(path, "depth.png"))
# Make the images of uniform size
image3 = changeImageSize(1500, 1000, image1)
image4 = changeImageSize(1500, 1000, image2)
# Make sure images got an alpha channel
image5 = image3.convert("RGBA")
image6 = image4.convert("RGBA")
# Display the images
# image6.show()
# image5.show()
# alpha-blend the images with varying values of alpha
alphaBlended1 = Image.blend(image5, image6, alpha=.2)
alphaBlended2 = Image.blend(image5, image6, alpha=.4)
# Display the alpha-blended images
# alphaBlended1.show()
alphaBlended2.save(join(path, 'blend.png'))
# plt.imshow(alphaBlended2)
# # plt.show()
#
# plt.imsave(join(path, 'blend.png'), alphaBlended2)
den = den.astype(np.float32, copy=False)
gt = np.sum(Image.fromarray(den))
print('gt:', gt)
den = den / np.max(den + 1e-20)
colored_density_map = cm(den)
density_map = Image.fromarray(
(colored_density_map[:, :, :3] * 255).astype(np.uint8))
img = Image.open(imagename)
img = img.resize((960, 544))
if img.mode == 'L':
img = img.convert('RGB')
img_RGBA = img.convert("RGBA")
density_map = density_map.convert("RGBA")
new_img = Image.blend(img_RGBA, density_map, 0.15)
input_img = img_transform(img)
d = ImageDraw.Draw(img)
d.text((10, 10),
"Ground Truth:{:.1f}".format(gt),
font=font,
fill=(255, 0, 0))
with torch.no_grad():
start_time = time.time()
pred_map = net.test_forward(Variable(input_img[None, :, :, :]).cuda())
elapsed_time = time.time() - start_time
print('inference time:{}'.format(elapsed_time))
fps += (1 / elapsed_time)
pred_map = pred_map.cpu().data.numpy()[0, 0, :, :]
def blend_image(self, image_obj, opacity, color="salmon"):
img1 = image_obj.convert("RGB")
img2 = Image.new("RGB", img1.size, color)
return Image.blend(img1, img2, opacity)
def texture_overlay(image, texture_file, alpha=0.5):
texture = util.load_pil_image_from_resource(TEXTURES_RESOURCE_PREFIX +
texture_file)
texture = texture.resize(image.size)
return Image.blend(image, texture, alpha)
def purpleTint(im):
'''purple tinted image'''
layer = Image.new('RGB', im.size, 'purple')
return Image.blend(im, layer, 0.5)
def redTint(im):
'''red tinted image'''
layer = Image.new('RGB', im.size, 'red')
return Image.blend(im, layer, 0.5)
genres = ['base', 'back', 'person', 'logo', 'deco', 'deco']
for i, url in enumerate(urls):
imgs.append(Image.open(url))
if button:
for trials in range(num_trials):
# 背景に色付け
draw = ImageDraw.Draw(imgs[0])
full_size = np.array(imgs[0].size)
base_color = np.random.randint(0, 255, 3)
draw.rectangle((0, 0, tuple(full_size)), fill=(
base_color[0], base_color[1], base_color[2]))
# 背景と混ぜた枠をセット※mode'RGBA'と'RGB'とかを揃える必要あり
imgs[1] = imgs[1].resize(tuple(full_size))
imgs[0] = Image.blend(imgs[0], imgs[1].convert('RGBA'), 0.5)
# 背景画像をセット
imgs[1] = imgs[1].resize(tuple(full_size-[20, 20]))
imgs[0].paste(imgs[1], (15, 10))
# 背景画像(通常1280,720)内に画像を散りばめる乱数を生成
number = len(imgs)
widths = []
heights = []
for k in range(number-2):
img_ratio = (imgs[k+2].width / imgs[k+2].height) ** 0.5
if genres[k+2] == 'logo':
size_base = 400
elif genres[k+2] == 'deco':
size_base = 100
def blueTint(im):
'''blue tinted image'''
layer = Image.new('RGB', im.size, 'blue')
return Image.blend(im, layer, 0.5)
# The second image - 'September.' Uses Mandelbrot, Color Method 2.
xmin, xmax, ymin, ymax = -1.786400592936561140507, -1.786395803871461587019, -0.000002098513044253179, 0.000001493285780411937
ImgC3 = Image.new("RGBA",(imgx,imgy))
ImgC3.paste((0,0,0), (0,0,imgx,imgy))
ImgC3.save("ImgC3.png","PNG")
VALCOL = "M2"
mandelbrot(ImgC3,"M2")
ImgC3.save("ImgC3.png","PNG")
ImgC3.show()
# The third image - 'Archipelago.' Uses Julia, Method 1, plus some Image Filtering from PIL to enhance color borders.
xmin, xmax, ymin, ymax, imgx, imgy, maxIt = 0.2, 0.25, -0.60, -0.55, 1500, 1500, 200
ImgC4 = Image.new("RGBA",(imgx,imgy))
ImgC4.paste((0,0,0), (0,0,imgx,imgy))
julia(ImgC4,complex(0.5,-0.3),"J1")
ImgC41 = ImgC4.filter(ImageFilter.EDGE_ENHANCE_MORE)
ImgC42 = ImgC4.filter(ImageFilter.CONTOUR)
ImgC4F = Image.blend(ImgC41, ImgC42, 0.05)
ImgC4F.save("ImgC4.png","PNG")
ImgC4F.show()
# The fourth image - 'Quartz.' Uses Julia, Method 2.
xmin, xmax, ymin, ymax, imgx, imgy, maxIt = 0.65, 0.75, -0.1, 0, 1000, 1000, 200
ImgC5 = Image.new("RGBA",(imgx,imgy))
julia(ImgC5,complex(-0.5,0.55),"J2")
ImgC5 = ImgC5.filter(ImageFilter.SHARPEN)
ImgC5.save("ImgC5.png","PNG")
ImgC5.show()
def inf(self, imgs, img_names, gt, inference, net, scales, pbar, base_img,
pos):
######################################################################
# Run inference
######################################################################
self.img_name = img_names[0]
col_img_name = '{}/{}_color.png'.format(self.rgb_path, self.img_name)
pred_img_name = '{}/{}.png'.format(self.pred_path, self.img_name)
diff_img_name = '{}/{}_diff.png'.format(self.diff_path, self.img_name)
compose_img_name = '{}/{}_compose.png'.format(self.compose_path,
self.img_name)
to_pil = transforms.ToPILImage()
if self.inference_mode == 'pooling':
img = imgs
pool_base_img = to_pil(base_img[0])
else:
img = to_pil(imgs[0])
prediction_pre_argmax_collection = inference(net, img, scales, pos)
# print(len(prediction_pre_argmax_collection))
# print(prediction_pre_argmax_collection[0].shape)
if self.inference_mode == 'pooling':
prediction = prediction_pre_argmax_collection
prediction = np.concatenate(prediction, axis=0)
else:
prediction_pre_argmax = np.mean(prediction_pre_argmax_collection,
axis=0)
prediction = np.argmax(prediction_pre_argmax, axis=0)
if self.metrics:
self.hist += fast_hist(prediction.flatten(),
gt.cpu().numpy().flatten(),
self.dataset_cls.num_classes)
iou_w = round(np.nanmean(per_class_iu(self.hist)) * 100, 2)
# acc_w = np.diag(self.hist).sum() / self.hist.sum()
H, W = prediction.shape
pred_split = np.split(prediction,
[H // 4, (H // 4) * 2, (H // 4) * 3],
axis=0)
gt_split = np.split(gt.cpu().numpy(),
[H // 4, (H // 4) * 2, (H // 4) * 3],
axis=1)
self.hist_up += fast_hist(pred_split[0].flatten(),
gt_split[0].flatten(),
self.dataset_cls.num_classes)
iou_u = round(np.nanmean(per_class_iu(self.hist_up)) * 100, 2)
# acc_u = np.diag(self.hist_up).sum() / self.hist_up.sum()
self.hist_mid1 += fast_hist(pred_split[1].flatten(),
gt_split[1].flatten(),
self.dataset_cls.num_classes)
iou_m1 = round(np.nanmean(per_class_iu(self.hist_mid1)) * 100, 2)
# acc_m1 = np.diag(self.hist_mid1).sum() / self.hist_mid1.sum()
self.hist_mid2 += fast_hist(pred_split[2].flatten(),
gt_split[2].flatten(),
self.dataset_cls.num_classes)
iou_m2 = round(np.nanmean(per_class_iu(self.hist_mid2)) * 100, 2)
# acc_m2 = np.diag(self.hist_mid2).sum() / self.hist_mid2.sum()
self.hist_down += fast_hist(pred_split[3].flatten(),
gt_split[3].flatten(),
self.dataset_cls.num_classes)
iou_d = round(np.nanmean(per_class_iu(self.hist_down)) * 100, 2)
# acc_d = np.diag(self.hist_down).sum() / self.hist_down.sum()
pbar.set_description(
"Mean IOU (Whole,Up,Mid1,Mid2,DOWN): %s %s %s %s %s" %
(str(iou_w), str(iou_u), str(iou_m1), str(iou_m2), str(iou_d)))
# pbar.set_description("ACC (Whole,Up,Mid,DOWN): %s %s %s %s" % (str(acc_w), str(acc_u), str(acc_m), str(acc_d)))
######################################################################
# Dump Images
######################################################################
if self.write_image:
if self.inference_mode == 'pooling':
img = pool_base_img
colorized = self.dataset_cls.colorize_mask(prediction)
colorized.save(col_img_name)
blend = Image.blend(img.convert("RGBA"), colorized.convert("RGBA"),
0.5)
blend.save(compose_img_name)
if gt is not None:
gt = gt[0].cpu().numpy()
# only write diff image if gt is valid
diff = (prediction != gt)
diff[gt == 255] = 0
diffimg = Image.fromarray(diff.astype('uint8') * 255)
PIL.ImageChops.lighter(
blend,
PIL.ImageOps.invert(diffimg).convert("RGBA")).save(
diff_img_name)
label_out = np.zeros_like(prediction)
for label_id, train_id in self.dataset_cls.id_to_trainid.items():
label_out[np.where(prediction == train_id)] = label_id
cv2.imwrite(pred_img_name, label_out)
def inf(self, imgs, img_names, gt, inference, net, scales, pbar, base_img):
######################################################################
# Run inference
######################################################################
self.img_name = img_names[0]
col_img_name = '{}/{}_color.png'.format(self.rgb_path, self.img_name)
pred_img_name = '{}/{}.png'.format(self.pred_path, self.img_name)
diff_img_name = '{}/{}_diff.png'.format(self.diff_path, self.img_name)
compose_img_name = '{}/{}_compose.png'.format(self.compose_path,
self.img_name)
to_pil = transforms.ToPILImage()
if self.inference_mode == 'pooling':
img = imgs
pool_base_img = to_pil(base_img[0])
else:
img = to_pil(imgs[0])
prediction_pre_argmax_collection = inference(net, img, scales)
if self.inference_mode == 'pooling':
prediction = prediction_pre_argmax_collection
prediction = np.concatenate(prediction, axis=0)[0]
else:
prediction_pre_argmax = np.mean(prediction_pre_argmax_collection,
axis=0)
prediction = np.argmax(prediction_pre_argmax, axis=0)
if self.metrics:
self.hist += fast_hist(prediction.flatten(),
gt.cpu().numpy().flatten(),
self.dataset_cls.num_classes)
iou = round(np.nanmean(per_class_iu(self.hist)) * 100, 2)
pbar.set_description("Mean IOU: %s" % (str(iou)))
######################################################################
# Dump Images
######################################################################
if self.write_image:
if self.inference_mode == 'pooling':
img = pool_base_img
colorized = self.dataset_cls.colorize_mask(prediction)
colorized.save(col_img_name)
blend = Image.blend(img.convert("RGBA"), colorized.convert("RGBA"),
0.5)
blend.save(compose_img_name)
if gt is not None and args.split != 'test':
gt = gt[0].cpu().numpy()
# only write diff image if gt is valid
diff = (prediction != gt)
diff[gt == 255] = 0
diffimg = Image.fromarray(diff.astype('uint8') * 255)
PIL.ImageChops.lighter(
blend,
PIL.ImageOps.invert(diffimg).convert("RGBA")).save(
diff_img_name)
label_out = np.zeros_like(prediction)
for label_id, train_id in self.dataset_cls.label2trainid.items():
label_out[np.where(prediction == train_id)] = label_id
cv2.imwrite(pred_img_name, label_out)
def __getitem__(self, item):
im_name = os.path.basename(self.image_lists[item])
# print(self.image_lists[item])
img = Image.open(self.image_lists[item]).convert("RGB")
width, height = img.size
if self.gts_dir is not None:
gt_path = os.path.join(self.gts_dir, im_name + ".txt")
words, boxes, charsbbs, segmentations, labels = self.load_gt_from_txt(
gt_path, height, width)
if words[0] == "":
use_char_ann = False
else:
use_char_ann = True
if not self.use_charann:
use_char_ann = False
target = BoxList(boxes[:, :4],
img.size,
mode="xyxy",
use_char_ann=use_char_ann)
if self.ignore_difficult:
labels = torch.from_numpy(np.array(labels))
else:
labels = torch.ones(len(boxes))
target.add_field("labels", labels)
masks = SegmentationMask(segmentations, img.size)
target.add_field("masks", masks)
char_masks = SegmentationCharMask(charsbbs,
words=words,
use_char_ann=use_char_ann,
size=img.size,
char_num_classes=len(
self.char_classes))
target.add_field("char_masks", char_masks)
else:
target = None
if self.transforms is not None:
img, target = self.transforms(img, target)
if self.vis:
new_im = img.numpy().copy().transpose([1, 2, 0]) + [
102.9801,
115.9465,
122.7717,
]
new_im = Image.fromarray(new_im.astype(np.uint8)).convert("RGB")
mask = target.extra_fields["masks"].polygons[0].convert("mask")
mask = Image.fromarray(
(mask.numpy() * 255).astype(np.uint8)).convert("RGB")
if self.use_charann:
m, _ = (target.extra_fields["char_masks"].chars_boxes[0].
convert("char_mask"))
color = self.creat_color_map(37, 255)
color_map = color[m.numpy().astype(np.uint8)]
char = Image.fromarray(color_map.astype(
np.uint8)).convert("RGB")
char = Image.blend(char, new_im, 0.5)
else:
char = new_im
new = Image.blend(char, mask, 0.5)
img_draw = ImageDraw.Draw(new)
for box in target.bbox.numpy():
box = list(box)
box = box[:2] + [box[2], box[1]] + box[2:] + [box[0], box[3]
] + box[:2]
img_draw.line(box, fill=(255, 0, 0), width=2)
new.save("./vis/char_" + im_name)
return img, target, self.image_lists[item]
def segmentChamber(videofile, dicomdir, view, model_path):
"""
"""
mean = 24
weight_decay = 1e-12
learning_rate = 1e-4
maxout = False
modeldir = model_path
if view == "a4c":
g_1 = tf.Graph()
with g_1.as_default():
label_dim = 6 # a4c
sess1 = tf.Session()
model1 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess1.run(tf.local_variables_initializer())
sess = sess1
model = model1
with g_1.as_default():
saver = tf.train.Saver()
saver.restore(
sess1, os.path.join(modeldir, "a4c_45_20_all_model.ckpt-9000"))
elif view == "a2c":
g_2 = tf.Graph()
with g_2.as_default():
label_dim = 4
sess2 = tf.Session()
model2 = Unet(mean,
weight_decay,
learning_rate,
label_dim,
maxout=maxout)
sess2.run(tf.local_variables_initializer())
sess = sess2
model = model2
with g_2.as_default():
saver = tf.train.Saver()
saver.restore(
sess2, os.path.join(modeldir,
"a2c_45_20_all_model.ckpt-10600"))
outpath = "/home/ubuntu/data/04_segmentation/" + view + "/"
if not os.path.exists(outpath):
os.makedirs(outpath)
images, orig_images = dcm_to_segmentation_arrays(dicomdir, videofile)
np_arrays_x3 = []
images_uuid_x3 = []
if view == "a4c":
a4c_lv_segs, a4c_la_segs, a4c_lvo_segs, preds = extract_segs(
images, orig_images, model, sess, 2, 4, 1)
np_arrays_x3.append(np.array(a4c_lv_segs).astype("uint8"))
np_arrays_x3.append(np.array(a4c_la_segs).astype("uint8"))
np_arrays_x3.append(np.array(a4c_lvo_segs).astype("uint8"))
number_frames = (np.array(a4c_lvo_segs).astype("uint8").shape)[0]
model_name = "a4c_45_20_all_model.ckpt-9000"
elif view == "a2c":
a2c_lv_segs, a2c_la_segs, a2c_lvo_segs, preds = extract_segs(
images, orig_images, model, sess, 2, 3, 1)
np_arrays_x3.append(np.array(a2c_lv_segs).astype("uint8"))
np_arrays_x3.append(np.array(a2c_la_segs).astype("uint8"))
np_arrays_x3.append(np.array(a2c_lvo_segs).astype("uint8"))
number_frames = (np.array(a2c_lvo_segs).astype("uint8").shape)[0]
model_name = "a2c_45_20_all_model.ckpt-10600"
j = 0
nrow = orig_images[0].shape[0]
ncol = orig_images[0].shape[1]
plt.figure(figsize=(5, 5))
plt.axis("off")
plt.imshow(imresize(preds, (nrow, ncol)))
plt.savefig(outpath + "/" + videofile + "_" + str(j) + "_" +
"segmentation.png")
images_uuid_x3.append(
hashlib.md5((outpath + "/" + videofile + "_" + str(j) + "_" +
"segmentation.png").encode()).hexdigest())
plt.close()
plt.figure(figsize=(5, 5))
plt.axis("off")
plt.imshow(orig_images[0])
plt.savefig(outpath + "/" + videofile + "_" + str(j) + "_" +
"originalimage.png")
images_uuid_x3.append(
hashlib.md5((outpath + "/" + videofile + "_" + str(j) + "_" +
"originalimage.png").encode()).hexdigest())
plt.close()
background = Image.open(outpath + "/" + videofile + "_" + str(j) + "_" +
"originalimage.png")
overlay = Image.open(outpath + "/" + videofile + "_" + str(j) + "_" +
"segmentation.png")
background = background.convert("RGBA")
overlay = overlay.convert("RGBA")
outImage = Image.blend(background, overlay, 0.5)
outImage.save(
outpath + "/" + videofile + "_" + str(j) + "_" + "overlay.png", "PNG")
images_uuid_x3.append(
hashlib.md5((outpath + "/" + videofile + "_" + str(j) + "_" +
"overlay.png").encode()).hexdigest())
return [number_frames, model_name, np_arrays_x3, images_uuid_x3]
def show_image(self):
plt.imshow(Image.blend(self.body.raw, self.veins.raw, 0.5),
cmap='gray')
plt.show()
def addTransparency(self, img, factor=0.0):
img = img.convert('RGBA')
img_blender = Image.new('RGBA', img.size, (0, 0, 256, 256))
img = Image.blend(img_blender, img, factor)
return img
def __and__(self, other):
""" Suporta a "conjunção bitwise" de 2 Imagem's ou de 1 Imagem e 1 Filtro
Suporta a sintaxe de uso do operador & em duas variantes:
objectoImagem & objectoImagem
objectoImagem & objectoFiltro
Se other for Imagem, é criada e devolvida uma nova Imagem cuja imagem
armazenada mistura as imagens dos dois operandos, usando a função
PIL.Image.blend com 50% de peso para cada imagem.
Se other for Filtro, é criada e devolvida uma nova Imagem cuja imagem
armazenada resulta de filtrar a imagem do self com o método PIL.Image.filter
usando o filtro armazenado no other.
Requires: other é instância de Imagem ou de Filtro.
Ensures:
uma nova Imagem com self.pathFicheiro == None, i.e., obtida no modo ii)
de __init__;
Caso em que other é Imagem:
novaImagem.nome é a concatenação dos nomes (sem sufixo) das duas Imagem's
"conjugadas" (misturadas), com a string "_mix_" de permeio;
novaImagem.etiquetas contém a união das etiquetas das duas Imagem's
"conjugadas", à qual é acrescentada, no fim da lista, a etiqueta
"mistura" (eliminando-se repetições de etiquetas);
novaImagem.descricao começa com a concatenação das descrições das duas
Imagem's "conjugadas", com mudança de linha entre uma e outra descrição;
seguem-se nova mudança de linha, e a string "A imagem descrita acima
resulta de uma mistura."
Caso em que other é Filtro:
novaImagem.nome é a concatenação do nome (sem sufixo) desta Imagem
com a string "_comFiltro_" + str(other)
novaImagem.etiquetas é uma cópia das etiquetas do self, à qual é
acrescentada, no fim da lista, a etiqueta "filtrada" (eliminando-se
repetições de etiquetas);
novaImagem.descricao é obtida repetindo a descrição da Imagem self,
fazendo uma mudança de linha, e acrescentando a string
"A imagem descrita acima foi filtrada."
"""
if isinstance(other, Imagem):
otherResize = other.imagem.resize(self.getTamanho())
blend = Image.blend(self.imagem, otherResize, 0.5)
novoNome = self.getNomeSemSufixo(
) + "_mix_" + other.getNomeSemSufixo()
novasEtiquetas = self.etiquetas[:] # evitar o aliasing!
for etiqueta in other.etiquetas:
if etiqueta not in novasEtiquetas:
novasEtiquetas.append(etiqueta)
if "mistura" not in novasEtiquetas:
novasEtiquetas.append("mistura")
novaDescricao = self.descricao + "\n" + other.descricao + "\n" + \
"A imagem descrita acima resulta de uma mistura."
novaImagem = Imagem(novoNome, imagem=blend)
else: # other é uma instância da classe Filtro
filtrada = self.imagem.filter(other.getFiltro())
novoNome = self.getNomeSemSufixo() + "_comFiltro_" + str(other)
novasEtiquetas = self.etiquetas[:] # evitar o aliasing!
if "filtrada" not in novasEtiquetas:
novasEtiquetas.append("filtrada")
novaDescricao = self.descricao + "\n" + \
"A imagem descrita acima foi filtrada."
novaImagem = Imagem(novoNome, imagem=filtrada)
novaImagem.etiquetas = novasEtiquetas # acesso directo ao atributo
novaImagem.setDescricao(novaDescricao)
return novaImagem
a.HEIGHT,
bgColor=a.BG_COLOR,
overwrite=a.OVERWRITE,
verbose=False)
# otherwise, draw image
else:
nfade = 1.0
# fading in or out
if fadeInStart <= ms <= fadeInEnd:
nfade = norm(ms, (fadeInStart, fadeInEnd), limit=True)
elif fadeOutStart <= ms <= fadeOutEnd:
nfade = 1.0 - norm(ms, (fadeOutStart, fadeOutEnd), limit=True)
if 0.0 < nfade < 1.0:
nfade = ease(nfade, a.FADE_EASE)
if nfade >= 1.0:
im.save(filename)
else:
fadedImg = Image.blend(blankImage, im, nfade)
fadedImg.save(filename)
printProgress(frame, totalFrames)
# Create a blank audio track
audioFile = a.OUTPUT_FILE.replace(".mp4", ".mp3")
makeBlankAudio(totalMs, audioFile)
compileFrames(a.OUTPUT_FRAME,
a.FPS,
a.OUTPUT_FILE,
getZeroPadding(totalFrames),
audioFile=audioFile)
# 通过Image.blend()可以将两张图片混合起来。它要求两张图片的大小必须一致。
from PIL import Image
image1 = Image.open('flower_01.jpg')
# 使用图片1的尺寸创建图片2,颜色为绿色。颜色那里也可以是元组表示RGB。
image2 = Image.new('RGB', image1.size, 'green')
image2.show()
# 将两张图片混合起来，最后一个参数是透明度，取值为0-1,它的值越大则表明image2的占比越高。image1*(1-alpha)+image2*alpha。透明度为0则完全为image1,透明度为1则完全为image2。
image3 = Image.blend(image1, image2, 0.6)
# 展示合成的图片
image3.show()
def f(img1, v):
i = np.random.choice(len(imgs))
img2 = Image.fromarray(imgs[i])
return Image.blend(img1, img2, v)
def overlap_image(img1, img2):
img = Image.blend(img1, img2, (math.sqrt(5) - 1) / 2)
return img
# filter: 滤波
# BLUR、CONTOUR、DETAIL、EDGE_ENHANCE、EDGE_ENHANCE_MORE、EMBOSS、FIND_EDGES、SMOOTH、SMOOTH_MORE、SHARPEN
# 模糊，均值滤波
image_blur = image.filter(ImageFilter.BLUR)
# 轮廓
image_contour = image.filter(ImageFilter.CONTOUR)
# 边缘检测
image_edge = image.filter(ImageFilter.FIND_EDGES)
# image_blur.show()
# image_contour.show()
# image_edge.show()
# blend: 融合，按照透明度
# out = image1 * (1 - alpha) + image2 * alpha
image_background = Image.open('images/background.jpg')
image_blend = Image.blend(image, image_background, 0.2)
# image_blend.show()
# split: 图片通道分离
image_r, image_g, image_b = image.split()
print(image_r.mode)
print(image_r.size)
'''
L
(768, 576)
'''
# composite: 图像融合
image_new = Image.composite(image, image_background, image_b)
# image_new.show()
from PIL import Image
im1 = Image.open("images/1.png")
im2 = Image.open("images/2.png")
im4 = Image.open("images/4.png")
im5 = Image.open("images/5.png")
im6 = Image.open("images/6.png")
im7 = Image.open("images/7.png")
im8 = Image.open("images/8.png")
im9 = Image.open("images/9.png")
i
for
Image.blend(im1, im2, .5).save("blended1.png")
blended = Image.open("blended1.png")
Image.blend(blended , im3, .5).save("blended1.png")
import operator
from PIL import Image
from PIL import ImageDraw
import cv2
cam = cv2.VideoCapture(0)
ret_val, original1 = cam.read()
img2 = cv2.flip(original1, 1)
ret_val, original = cam.read()
img1 = cv2.flip(original, 1)
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
img1 = Image.fromarray(img1)
# suppose img2 is to be shifted by `shift` amount
shift = (50, 60)
print(img2.size)
# compute the size of the panorama
nw, nh = map(max, map(operator.add, img1.size, shift), img1.size)
# paste img1 on top of img2
newimg1 = Image.new('RGBA', size=(nw, nh), color=(0, 0, 0, 0))
newimg1.paste(img1, shift)
newimg1.paste(img1, (0, 0))
# paste img2 on top of img1
newimg2 = Image.new('RGBA', size=(nw, nh), color=(0, 0, 0, 0))
newimg2.paste(img1, (0, 0))
newimg2.paste(img1, shift)
# blend with alpha=0.5
result = Image.blend(newimg1, newimg2, alpha=0.5)
#Open Images
img = Image.open(inputImage)
triggImg = Image.open("triggered.jpg")
#Convert image to jpg
rgbimg = img.convert('RGB')
img = rgbimg
#Adding a red effect to an image
redimg = Image.open("red.jpg")
p, q = img.size
redimg = redimg.resize((p, q), Image.ANTIALIAS)
h, k = redimg.size
print(p, q, h, k, img.mode, redimg.mode)
blendedimg = Image.blend(img, redimg, 0.4)
img = blendedimg
#Adding the "triggered" to an image
newimg = img
p, q = newimg.size
newimg = newimg.crop((0, 0, p, q + math.ceil(q / 6)))
p, q = newimg.size
newTrigg = triggImg.resize((p, math.ceil(q / 6)), Image.ANTIALIAS)
newimg.paste(newTrigg, (0, math.ceil(q - (q / 6))))
newimg.save('test.png')
img = newimg
#Counter for the loop
i = 1