def overlay_icon_to_vim(icon, cache):
bg = Image.open(VIMICON)
overlay_size = 10
overlay = Image.open(icon).resize((overlay_size, overlay_size), Image.ANTIALIAS)
fg = Image.new("RGBA", (16, 16))
fg.paste(overlay, (16 - overlay_size, 16 - overlay_size, 16, 16))
Image.alpha_composite(bg, fg).save(cache)
def diff(self):
self.run_ss = [run for run in os.listdir(self.run_dir)]
self.gold_ss = [gold for gold in os.listdir(self.gold_dir)]
if self.mask_dir:
self.mask_ss = [mask for mask in os.listdir(self.mask_dir)]
if self.run_ss != self.gold_ss:
print 'Missing screenshots: %s' % str(list(set(self.gold_ss).difference(self.run_ss)))
print 'Extra screenshots: %s' % str(list(set(self.run_ss).difference(self.gold_ss)))
# Diff all the images common to run and gold directories
for ss in list(set(self.run_ss).intersection(self.gold_ss)):
try:
# Apply the mask, if it exists
if self.mask_dir and (ss in self.mask_ss):
base = Image.open(self.run_dir + ss)
mask = Image.open(self.mask_dir + ss)
Image.alpha_composite(base, mask).save(self.run_dir+ss)
if not self.images_identical(self.gold_dir + ss, self.run_dir + ss):
rms = self.image_diff(self.gold_dir + ss, self.run_dir + ss, self.diff_dir + ss, (255, 0, 0))[0]
# Experimentally found value, "fuzziness factor"
if rms < self.fuzzy:
pass
else:
print 'Diff failed! %s is not identical enough.' % ss
except AssertionError:
print "Diff failed! %s. Images have different dimensions or pixel modes." % ss
def map_wards(data):
accumulator = 1
frames = set_frames(data)
for e in range(len(data)):
index = round(data[e]["time"] / 60000) - 1
im = Image.new('RGBA', (512, 512))
draw = ImageDraw.Draw(im, "RGBA")
if data[e]["team"] == 100:
color = (0, 0, 126, 200)
elif data[e]["team"] == 200:
color = (126, 0, 0, 200)
x = data[e]["position"]["x"] + x_off
y = data[e]["position"]["y"] + y_off
draw.ellipse([x / scale - d, y / scale - d, x / scale + d, y / scale + d], fill=color)
del draw
frames[index] = Image.alpha_composite(frames[index], im)
for image in frames:
canvas = Image.open('minimap-mh.png').convert("RGBA")
Image.alpha_composite(canvas, image.transpose(Image.FLIP_TOP_BOTTOM)).save(
"C:/Users/Eddie/PycharmProjects/WardScan/frames/{}.png".format(accumulator), "PNG")
accumulator += 1
def snapshot(image):
global ready
global overlay
global merci
global misc
global pos
global live
global camera
print 'image: ', image
print 'real image: ', str(misc['images'][image])
filename = time.strftime('%Y%m%d') + '-' + time.strftime('%H%M%S')
print 'filename: ' + filename
message = 'snapshot: ' + filename
tStatus = threading.Thread(name='status', target=status, args=(message,))
tStatus.daemon = True
tStatus.start()
ready['capture'] = int(time.time())
print 'camera: capture start'
camera.capture(misc['snapshots'] + filename + misc['ext'], format='png')
print 'camera: capture done'
ready['capture'] = 0
ready['upload'] = False
ready['print'] = False
print 'ready (upload): ', ready['upload']
print 'ready (print): ', ready['print']
print 'resize'
# MERGING IMAGES
resize_canvas(misc['snapshots'] + filename + misc['ext'],misc['snapshots'] + filename + misc['ext'],pos[misc['images'][image]]['x'],pos[misc['images'][image]]['y'])
background = Image.open(misc['snapshots'] + filename + misc['ext'])
foreground = Image.open(misc['cards'] + str(misc['images'][image]) + '.png')
print 'merge'
Image.alpha_composite(background, foreground).save(misc['compositions'] + filename + misc['ext'])
print 'prepare'
tPrepare = threading.Thread(name='prepare', target=prepare, args=(filename,misc['images'][image],))
tPrepare.daemon = True
tPrepare.start()
merci = subprocess.Popen(['/home/pi/raspidmx/pngview/./pngview','-b','0','-l','4','/home/pi/Photobooth/merci/merci.png'])
sleep(10)
print 'setup'
tSetup = threading.Thread(name='setup', target=setup)
tSetup.daemon = True
tSetup.start()
def snapshot(image):
global ready
global misc
global merci
global camera
print "image: ", image
print "real image: ", str(misc["images"][image])
filename = time.strftime("%Y%m%d") + "-" + time.strftime("%H%M%S")
print "filename: ", filename
ready["capture"] = int(time.time())
print "camera: capture start"
camera.capture(misc["snapshots"] + filename + misc["ext"], format="png")
print "camera: capture done"
ready["capture"] = 0
ready["upload"] = False
ready["print"] = False
print "ready (upload): ", ready["upload"]
print "ready (print): ", ready["print"]
print "resize"
# MERGING IMAGES
resize_canvas(
misc["snapshots"] + filename + misc["ext"],
misc["snapshots"] + filename + misc["ext"],
pos[misc["images"][image]]["x"],
pos[misc["images"][image]]["y"],
)
background = Image.open(misc["snapshots"] + filename + misc["ext"])
foreground = Image.open(misc["cards"] + str(misc["images"][image]) + ".png")
print "merge"
Image.alpha_composite(background, foreground).save(misc["compositions"] + filename + misc["ext"])
print "prepare"
tPrepare = threading.Thread(name="prepare", target=prepare, args=(filename, misc["images"][image]))
tPrepare.daemon = True
tPrepare.start()
merci = subprocess.Popen(
["/home/pi/raspidmx/pngview/./pngview", "-b", "0", "-l", "4", "/home/pi/Photobooth/merci/merci.png"]
)
sleep(10)
print "setup"
tSetup = threading.Thread(name="setup", target=setup)
tSetup.daemon = True
tSetup.start()
def meme_image(image_name, memename, serverid):
print("Creating " + memename + " meme using " + image_name + " for server " + serverid)
with open("info.json", "r") as info_file:
data = info_file.read()
data = json.loads(data)
if not os.path.isfile("images/" + data["memes_images"][memename]["image"]):
print("Downloading new Images")
file_download(data["memes_images"][memename]["image_url"], "images/", data["memes_images"][memename]["image"])
frame = Image.open("images/" + data["memes_images"][memename]["image"]).convert("RGBA")
pic = Image.open("server/" + serverid + "/" + image_name).convert("RGBA")
if data["memes_images"][memename]["background"] == True:
box = data["memes_images"][memename]["box"]
if pic.size[0] < pic.size[1]:
scale = (box[2]/pic.size[0])
pic = pic.resize((box[2],int(pic.size[1]*scale)), PIL.Image.ANTIALIAS)
if pic.size[1] < box[3] - box[1]:
scale = (box[3]/pic.size[1])
pic = pic.resize(((int(pic.size[0]*scale),box[3])), PIL.Image.ANTIALIAS)
else:
scale = (box[3]/pic.size[1])
pic = pic.resize(((int(pic.size[0]*scale),box[3])), PIL.Image.ANTIALIAS)
if pic.size[0] < box[2] - box[0]:
scale = (box[2]/pic.size[0])
pic = pic.resize((box[2],int(pic.size[1]*scale)), PIL.Image.ANTIALIAS)
center = [(pic.size[0]-box[2])/2, (pic.size[1]-box[3])/2]
pic = pic.crop((center[0],center[1],center[0]+box[2],center[1]+box[3]))
frame.paste(pic,(box[0],box[1]))
background = Image.new('RGBA', frame.size, (data["memes_images"][memename]["backgrond_color"][0],data["memes_images"][memename]["backgrond_color"][1],data["memes_images"][memename]["backgrond_color"][2],data["memes_images"][memename]["backgrond_color"][3]))
frame = Image.alpha_composite(background, frame)
frame.save("server/" + serverid + "/output/"+ data["memes_images"][memename]["image"]);
else:
if pic.size[1] < frame.size[1]:
scale = (frame.size[1]/pic.size[1])
pic = pic.resize(((int(pic.size[0]*scale),frame.size[1])), PIL.Image.ANTIALIAS)
if pic.size[0] < frame.size[0]:
scale = (frame.size[0]/pic.size[0])
pic = pic.resize((frame.size[0],int(pic.size[1]*scale)), PIL.Image.ANTIALIAS)
if pic.size[1] < frame.size[1]:
scale = (frame.size[1]/pic.size[1])
pic = pic.resize(((int(pic.size[0]*scale),frame.size[1])), PIL.Image.ANTIALIAS)
if pic.size[0] < frame.size[0]:
scale = (frame.size[0]/pic.size[0])
pic = pic.resize((frame.size[0],int(pic.size[1]*scale)), PIL.Image.ANTIALIAS)
pic.paste(frame, (10, pic.size[1]-frame.size[1]-30),frame)
background = Image.new('RGBA', pic.size, (data["memes_images"][memename]["backgrond_color"][0],data["memes_images"][memename]["backgrond_color"][1],data["memes_images"][memename]["backgrond_color"][2],data["memes_images"][memename]["backgrond_color"][3]))
pic = Image.alpha_composite(background, pic)
pic.save("server/" + serverid + "/output/"+ data["memes_images"][memename]["image"]);
print(memename + " meme saved to: server/" + serverid + "/output/" + data["memes_images"][memename]["image"])
return("server/" + serverid + "/output/" + data["memes_images"][memename]["image"])
def images_identical(path1, path2, mask_path):
if not os.path.exists(path1):
return False
im1 = Image.open(path1)
im2 = Image.open(path2)
if im1.size != im2.size:
return False
if mask_path != None:
mask = Image.open(mask_path)
im1 = Image.alpha_composite(im1, mask)
im2 = Image.alpha_composite(im2, mask)
return ImageChops.difference(im1, im2).getbbox() is None
def image_diff(path1, path2, outpath, diffcolor, mask_path):
if not os.path.exists(path1):
im2 = Image.open(path2)
return (1000, im2.size[0], im2.size[1])
im1 = Image.open(path1)
im2 = Image.open(path2)
if im1.size != im2.size:
return (1000, im2.size[0], im2.size[1])
if mask_path != None:
mask = Image.open(mask_path)
im1 = Image.alpha_composite(im1, mask)
im2 = Image.alpha_composite(im2, mask)
rmsdiff = rmsdiff_2011(im1, im2)
pix1 = im1.load()
pix2 = im2.load()
if im1.mode != im2.mode:
raise TestError('Different pixel modes between %r and %r' % (path1, path2))
if im1.size != im2.size:
raise TestError('Different dimensions between %r (%r) and %r (%r)' % (path1, im1.size, path2, im2.size))
mode = im1.mode
if mode == '1':
value = 255
elif mode == 'L':
value = 255
elif mode == 'RGB':
value = diffcolor
elif mode == 'RGBA':
value = diffcolor + (255,)
elif mode == 'P':
raise NotImplementedError('TODO: look up nearest palette color')
else:
raise NotImplementedError('Unexpected PNG mode')
width, height = im1.size
for y in xrange(height):
for x in xrange(width):
if pix1[x, y] != pix2[x, y]:
pix2[x, y] = value
im2.save(outpath)
return (rmsdiff, width, height)
def save_sketch(request, id):
# this saves the sketch
canvasData = request.POST.get('canvasData', None)
if not canvasData:
return
img_string = canvasData.replace("data:image/png;base64,", "")
img_data = img_string.decode("base64")
img_file = StringIO.StringIO(img_data)
# now merge with the background
backimgfn = '%s/static/case_form_background.png' % settings.BASE_DIR
background = Image.open(backimgfn)
foreground = Image.open(img_file)
fn = '%s/uploads/sketch%s.png' % (settings.BASE_DIR, id)
Image.alpha_composite(background, foreground).save(fn)
img_file.close()
def generate_stars(tasks_to_write):
foreground = Image.open('stars.png')
for page in tasks_to_write:
for task in page:
file_name = 'tmp/img/{}-star.png'.format(task['id'])
background = Image.new('RGBA', (440, 84), (255, 255, 255, 255))
draw = ImageDraw.Draw(background)
draw.rectangle(
((0, 0), (int(round(4.4 * task['stars'])), 84)),
fill='black')
Image.alpha_composite(background, foreground) \
.save(open(file_name, 'w+b'))
def overlayOnPart(src_image, overlay_image, posX, posY):
# オーバレイ画像のサイズを取得
ol_height, ol_width = overlay_image.shape[:2]
# OpenCVの画像データをPILに変換
# BGRAからRGBAへ変換
src_image_RGBA = cv2.cvtColor(src_image, cv2.COLOR_BGR2RGB)
overlay_image_RGBA = cv2.cvtColor(overlay_image, cv2.COLOR_BGRA2RGBA)
# PILに変換
src_image_PIL=Image.fromarray(src_image_RGBA)
overlay_image_PIL=Image.fromarray(overlay_image_RGBA)
# 合成のため、RGBAモードに変更
src_image_PIL = src_image_PIL.convert('RGBA')
overlay_image_PIL = overlay_image_PIL.convert('RGBA')
# 同じ大きさの透過キャンパスを用意
tmp = Image.new('RGBA', src_image_PIL.size, (255, 255,255, 0))
# 用意したキャンパスに上書き
tmp.paste(overlay_image_PIL, (posX, posY), overlay_image_PIL)
# オリジナルとキャンパスを合成して保存
result = Image.alpha_composite(src_image_PIL, tmp)
# COLOR_RGBA2BGRA から COLOR_RGBA2BGRに変更。アルファチャンネルを含んでいるとうまく動画に出力されない。
return cv2.cvtColor(np.asarray(result), cv2.COLOR_RGBA2BGR)
def overlayOnPart(src_image, overlay_image, posX, posY, zoom):
# オーバレイ画像を倍率に合わせて拡大縮小
resized_overlay_image = resize_image(overlay_image, zoom)
# オーバレイ画像のサイズを取得
ol_height, ol_width = resized_overlay_image.shape[:2]
# OpenCVの画像データをPILに変換
# BGRAからRGBAへ変換
src_image_RGBA = cv2.cvtColor(src_image, cv2.COLOR_BGR2RGB)
resized_overlay_image_RGBA = cv2.cvtColor(resized_overlay_image, cv2.COLOR_BGRA2RGBA)
# PILに変換
src_image_PIL=Image.fromarray(src_image_RGBA)
resized_overlay_image_PIL=Image.fromarray(resized_overlay_image_RGBA)
# 合成のため、RGBAモードに変更
src_image_PIL = src_image_PIL.convert('RGBA')
resized_overlay_image_PIL = resized_overlay_image_PIL.convert('RGBA')
# 同じ大きさの透過キャンパスを用意
tmp = Image.new('RGBA', src_image_PIL.size, (255, 255,255, 0))
# rect[0]:x, rect[1]:y, rect[2]:width, rect[3]:height
# 用意したキャンパスに上書き
tmp.paste(resized_overlay_image_PIL, (int(posX-ol_height/2), int(posY-ol_width/2)), resized_overlay_image_PIL)
# オリジナルとキャンパスを合成して保存
result = Image.alpha_composite(src_image_PIL, tmp)
return cv2.cvtColor(np.asarray(result), cv2.COLOR_RGBA2BGR)
def test_fit_in_rectangle_transparent_no_resize(self):
# And with a transparent test image, check alpha blending.
image = 'pattern-transparent-rgba.png'
control = Image.open(get_image_path(image))
# Create checkerboard background.
checker_bg = Image.new('RGBA', control.size)
checker = Image.open(get_image_path('checkerboard.png'))
for x in range(0, control.size[0], checker.size[0]):
for y in range(0, control.size[1], checker.size[1]):
checker_bg.paste(checker, (x, y))
# Create whhite background.
white_bg = Image.new('RGBA', control.size, color='white')
assert control.size == white_bg.size
width, height = control.size
for use_checker_bg in (False, True):
prefs['checkered bg for transparent images'] = use_checker_bg
expected = Image.alpha_composite(
checker_bg if use_checker_bg else white_bg,
control
)
for scaling_quality in range(4):
prefs['scaling quality'] = scaling_quality
result = image_tools.fit_in_rectangle(image_tools.pil_to_pixbuf(control),
width, height,
scaling_quality=scaling_quality)
msg = (
'fit_in_rectangle("%s", scaling quality=%d, background=%s) failed; '
'result %%(diff_type)s differs: %%(diff)s'
% (image, scaling_quality, 'checker' if checker_bg else 'white')
)
self.assertImagesEqual(result, expected, msg=msg)
def test_alpha_composite(self):
# http://stackoverflow.com/questions/3374878
# Arrange
from PIL import ImageDraw
expected_colors = sorted([
(1122, (128, 127, 0, 255)),
(1089, (0, 255, 0, 255)),
(3300, (255, 0, 0, 255)),
(1156, (170, 85, 0, 192)),
(1122, (0, 255, 0, 128)),
(1122, (255, 0, 0, 128)),
(1089, (0, 255, 0, 0))])
dst = Image.new('RGBA', size=(100, 100), color=(0, 255, 0, 255))
draw = ImageDraw.Draw(dst)
draw.rectangle((0, 33, 100, 66), fill=(0, 255, 0, 128))
draw.rectangle((0, 67, 100, 100), fill=(0, 255, 0, 0))
src = Image.new('RGBA', size=(100, 100), color=(255, 0, 0, 255))
draw = ImageDraw.Draw(src)
draw.rectangle((33, 0, 66, 100), fill=(255, 0, 0, 128))
draw.rectangle((67, 0, 100, 100), fill=(255, 0, 0, 0))
# Act
img = Image.alpha_composite(dst, src)
# Assert
img_colors = sorted(img.getcolors())
self.assertEqual(img_colors, expected_colors)
def combine_images(images):
returnimage = None
for i in images:
if i:
image = Image.open(io.BytesIO(i)).convert('RGBA')
# make all white pixels transparent
pixdata = image.load()
width, height = image.size
for y in xrange(height):
for x in xrange(width):
if pixdata[x, y] == (255, 255, 255, 255):
pixdata[x, y] = (255, 255, 255, 0)
if not returnimage:
returnimage = image
else:
baseimage = returnimage
imagetoadd = image
returnimage = Image.alpha_composite(
baseimage,
imagetoadd
)
if returnimage:
with io.BytesIO() as output:
returnimage.save(output, 'PNG')
return output.getvalue()
return None
def make_cover_image(item):
if item.image_counter and item.compilation_cds != 1:
base = Image.open(item.image_path).convert('RGBA')
overlay = Image.new('RGBA', base.size, (255,255,255,0))
fnt = ImageFont.truetype('garamond8.ttf', base.size[0] // 15)
d = ImageDraw.Draw(overlay)
counter = str(item.image_counter)
textsize = d.textsize(counter, font=fnt)
draw_position = (base.size[0] / 2, int(base.size[1] * 0.9))
circle_radius = max(textsize) // 2
circle_bounds = [(draw_position[0] - circle_radius, draw_position[1] - circle_radius),
(draw_position[0] + circle_radius, draw_position[1] + circle_radius)]
text_position = (draw_position[0] - textsize[0]/2, draw_position[1] - textsize[1]//1.5)
d.ellipse(circle_bounds, fill=(255,255,255,64))
#d.ellipse([(draw_position[0] - 5, draw_position[1] - 5), (draw_position[0] + 5, draw_position[1] + 5)], fill=(255,0,0,128))
#d.ellipse([(text_position[0] - 5, text_position[1] - 5), (text_position[0] + 5, text_position[1] + 5)], fill=(0,255,0,128))
d.text(text_position, counter, font=fnt, fill=(64,64,64,255))
'''
print 'draw_position;', draw_position
print 'text_position:', text_position
print 'fontsize:', base.size[0] // 10
print 'base.size:', base.size
print 'textsize:', textsize
print 'circle_radius:', circle_radius
'''
out = Image.alpha_composite(base, overlay)
label_path = os.path.join(cd_tracks_folder, item.name) + '_' + counter + '.jpg'
out.save(label_path, 'jpeg')
else:
label_path = os.path.join(config.cd_tracks_folder, item.name) + '.jpg'
shutil.copy(item.image_path, label_path)
return label_path
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 watermarkTest(subreddit): textBase = emptyBase # make a blank image for the text, initialized to transparent text color width = image.size[0] height = image.size[1] # get a font fnt = ImageFont.truetype(fontDirectory + "BRADHITC.ttf", size=200) fntHeight = fnt.getsize(subreddit)[1] # creates an object that will be drawn onto textBase draw = ImageDraw.Draw(textBase) # draw text, half opacity #print "image width:", imageWidth, "image height:", imageHeight #print "1/6 width", 1 * imageWidth / 6, "1/6 height", 1 * imageHeight / 6 draw.text((width / 48, 47 * height / 48 - fntHeight), subreddit, font=fnt, fill=(255, 255, 255,255)) # draw text, full opacity #print "the font width is:", draw.textsize(subreddit, font=fnt)[0] #d.show() textDimensions = draw.textsize(subreddit, font=fnt) out = Image.alpha_composite(image, textBase) #outWithLines = Image.alpha_composite(out, textPlacementTest(emptyBase, textDimensions)) out.save(filepath + "test.jpg")
def render(self, context):
assert isinstance(context, RenderContext)
feature1 = self._nodes[0].render(context)
if feature1 is None:
raise RuntimeError('Render Failed, Node: %s, Context: %r',
self._nodes[0].name, context)
src = feature1.data
feature2 = self._nodes[1].render(context)
if feature2 is None:
raise RuntimeError('Render Failed, Node: %s, Context: %r',
self._nodes[1].name, context)
dst = feature2.data
if src.mode != dst.mode:
if src.mode != 'RGBA':
src = src.convert(mode='RGBA')
if dst.mode != 'RGBA':
dst = dst.convert(mode='RGBA')
pil_image = Image.alpha_composite(dst, src)
if pil_image.mode != 'RGBA':
pil_image = pil_image.convert(mode='RGBA')
feature = ImageFeature(
crs=context.map_proj,
bounds=context.map_bbox,
size=context.map_size,
data=pil_image
)
return feature
def process_tall_image(im):
black = Image.new('RGBA', im.size, color=(0,0,0,255))
im_on_black_background = Image.alpha_composite(black, im)
scaling_factor = OUTPUT_RES[0] / im.width
output_height = round(im.height * scaling_factor)
#im_on_black_background.thumbnail((OUTPUT_RES[0], 9999999999)) #resize such that width is 1707, but height can be whatever
return im_on_black_background.resize((OUTPUT_RES[0],output_height), resample=Image.LANCZOS)
def plot_to_map(coordinates, names, colors):
'''
Takes as input three lists, which should all line-up:
- names (list in which all province/state names are stored)
- coordinates (list with coordinates formatted as (x,y))
- colors ()
'''
# load basemap image and make blank image for text
basemap = Image.open('spain_.jpg').convert('RGBA')
txt = Image.new('RGBA', basemap.size)
# get font
font = ImageFont.truetype('calibri.ttf', 20)
# get a drawing context
draw = ImageDraw.Draw(txt)
for i in range(len(names)):
# draw text on map, rotate colors
draw.text(locations[i], names[i], font=font, fill=colors[i%len(colors)])
# draw text layer on top of image layer
out = Image.alpha_composite(basemap, txt)
# showtime ..
out.show()
def iconAssembler(basedir, button, template, colors, background):
background = background.strip()
template = template.strip()
backDir = os.path.join(basedir, "themes", "backgrounds", '')
themeDir = os.path.join(basedir, "themes")
back = Image.open(os.path.join(backDir + str(background + ".png")))
back = back.convert('RGBA')
mask = Image.open(os.path.join(themeDir, template, str(button +
"Mask.png")))
mask = mask.convert('L')
back.putalpha(mask)
layers = list()
for count, color in enumerate(colors):
color.strip()
filename = ''
try:
filename = os.path.join(themeDir, template, str(button + str(
count) + ".png"))
layer = Image.open(filename)
except:
status = "Not enough colors! Can't open " + filename
return status, None
layer = layer.convert('RGBA')
if color != "same":
try:
layer = replaceColors(layer, color)
except:
status = "Couldn't colorshift " + filename + " to " + color \
+ "! Possible bad color string?"
return status, None
back = Image.alpha_composite(back, layer)
status = "Successfully generated icons!"
return status, back
def body(player, *, player_skin=None, model=None, hat=True, profile_id=None, error_log=None):
if error_log is None:
error_log = sys.stderr
if player_skin is None or model is None:
player_skin, model = skin(player, profile_id=profile_id, error_log=error_log)
result = Image.new('RGBA', (16, 32))
result.paste(player_skin.crop((8, 8, 16, 16)), (4, 0)) # head
result.paste(player_skin.crop((20, 20, 28, 32)), (4, 8)) # body
result.paste(player_skin.crop((4, 20, 8, 32)), (4, 20)) # right leg
result.paste(player_skin.crop((44, 20, 47 if model == 'alex' else 48, 32)), (1 if model == 'alex' else 0, 8)) # right arm
if player_skin.size[1] == 32: # old-style skin
result.paste(player_skin.crop((4, 20, 8, 32)).transpose(Image.FLIP_LEFT_RIGHT), (8, 20)) # left leg
result.paste(player_skin.crop((44, 20, 47 if model == 'alex' else 48, 32)).transpose(Image.FLIP_LEFT_RIGHT), (12, 8)) # left arm
else: # new-style skin
result.paste(player_skin.crop((20, 52, 24, 64)), (8, 20)) # left leg
result.paste(player_skin.crop((36, 52, 39 if model == 'alex' else 40, 64)), (12, 8)) # left arm
with player_skin:
if hat:
hat_layer = Image.new('RGBA', (16, 32))
hat_layer.paste(player_skin.crop((40, 8, 48, 16)), (4, 0)) # hat
if player_skin.size[1] == 64: # new-style skin
hat_layer.paste(player_skin.crop((20, 36, 28, 48)), (4, 8)) # jacket
hat_layer.paste(player_skin.crop((4, 36, 8, 48)), (4, 20)) # right pants leg
hat_layer.paste(player_skin.crop((44, 36, 47 if model == 'alex' else 48, 48)), (1 if model == 'alex' else 0, 8)) # right sleeve
hat_layer.paste(player_skin.crop((4, 52, 8, 64)), (8, 20)) # left pants leg
hat_layer.paste(player_skin.crop((52, 52, 55 if model == 'alex' else 56, 64)), (12, 8)) # left sleeve
return Image.alpha_composite(result, hat_layer)
return result
def build_lyrics(source, text):
source = copy(source)
width = source.size[0]
height = source.size[1]
process = Image.new('RGBA', (width, height), (0,0,0))
half_width = int(math.floor(width / 2))
half_height = int(math.floor(height / 2))
# get a font
fnt_b = ImageFont.truetype('data/drawing/font_bold.ttf', 40)
# get a drawing context
d = ImageDraw.Draw(process)
# haax
d.rectangle([(0,0),(width,height)], fill=(0,0,0,0))
# calculate position
text_pos = int(math.floor(fnt_b.getsize(text)[0] / 2))
# draw
d.rectangle([(10, height - 70),(width - 10, height - 10)], fill=(0,0,0,160))
d.text((half_width - text_pos, height - 55), text, font=fnt_b, fill=(255,255,255,255))
return Image.alpha_composite(source, process)
def process_image(img):
#open up the mask
mask = Image.open('mask.png')
mask = mask.convert('RGBA')
#make sure it matches the size of the image
mask = mask.resize(img.size)
#make sure our image has alpha channel
img = img.convert('RGBA')
#unique name
filename = uuid.uuid4().hex + '.png'
filename = os.path.join('/tmp', filename)
Image.alpha_composite(img, mask).save(filename, 'PNG')
#send it back
return filename
def add_actors(out_img, actors):
for actor in actors:
if actor.image:
img_path = actor.image
img = Image.open(img_path).convert("RGBA")
shape = actor.clip
sprite = img.crop(make_box(*shape))
if actor.effect:
apply_effect(sprite, actor.effect)
x = actor.x * TILE_SIZE
y = actor.y * TILE_SIZE
paste_shape = [x, y] + list(sprite.size)
if actor.zoom:
new_x, new_y, new_w, new_h, scale = actor.zoom
sprite = sprite.resize([new_w, new_h])
x = new_x * TILE_SIZE
y = new_y * TILE_SIZE
paste_shape = [x, y] + list(sprite.size)
paste_box = make_box(*paste_shape)
bg = out_img.crop(paste_box)
mixed = None
if actor.effect:
mixed = add_composite(bg, sprite)
else:
mixed = Image.alpha_composite(bg, sprite)
out_img.paste(mixed, paste_box)
def resize_the_image(self, infile):
filename = self.create_filename()
new_file_path = os.path.join(self.destination_folder, filename)
im = Image.open(infile)
align = "horizontal"
size = (self.output_width, self.output_height)
if im.size[0] <= im.size[1]:
size = (self.output_height, self.output_width)
align = "vertical"
new_image = im.resize(size, Image.ANTIALIAS)
self.__increase_seq_value()
self.__increase_processed_images()
self.__resized_images += (new_file_path,)
if self.is_copyright():
if align == "horizontal":
copyright_layer = self.__horizontal_copyright
else:
copyright_layer = self.__vertical_copyright
new_image = new_image.convert('RGBA')
out = Image.alpha_composite(new_image, copyright_layer)
out.save(new_file_path)
else:
new_image.save(new_file_path)
del im
del new_image
def place_text(self, text, color, angle):
assert len(color) == 4
image_size = self.background.size
txt = Image.new('RGBA', image_size, (255, 255, 255, 0))
text_size = int((image_size[0] + image_size[1]) / 40)
font = ImageFont.truetype("comic.ttf", text_size)
d = ImageDraw.Draw(txt)
d.text((0, -5), text, font=font, fill=color)
w, h = d.textsize(text, font)
coords = self.generate_coords(w)
txt = txt.crop((0,0, w, h))
txt1 = txt.rotate(angle, expand=True)
txt = Image.new('RGBA', self.background.size, (255, 255, 255, 0))
text_coords = (int(coords[0] - w/2), int(coords[1] - h/2))
txt.paste(txt1, text_coords)
self.background = Image.alpha_composite(self.background, txt)
return self
def makeChatLine(self):
xGapL = self.attrDict["xGapL"]
yGapT = self.attrDict["yGapT"]
xGapR = self.attrDict["xGapR"]
im = Image.new("RGBA", (720, self.attrDict["totalHeight"]), self.attrDict["backgroundColor"])
imD = ImageDraw.Draw(im, "RGBA")
if self.person == "sender":
imD.rectangle(
[(xGapL, yGapT), (xGapL + self.attrDict["chatWidth"], yGapT + self.attrDict["chatHeight"])],
self.attrDict["chatboxColor1"],
self.attrDict["outlineColor"],
)
else:
imD.rectangle(
[(xGapR, yGapT), (xGapR + self.attrDict["chatWidth"], yGapT + self.attrDict["chatHeight"])],
self.attrDict["chatboxColor2"],
self.attrDict["outlineColor"],
)
if self.person == "sender":
blueTick = Image.open("whatsapp_assets/bluetick.png")
im.paste(
blueTick, (643, self.attrDict["textHeight"] - 27)
) # 643 is the X-position, located 27 pixels from bottom of the chat snippet
txt = self.textFormat()
out = Image.alpha_composite(im, txt)
# out.show()
return out
def photo_enhance(desc_info):
img = Image.open('bing.jpg').convert('RGBA')
txt = Image.new('RGBA', img.size, (255, 255, 255, 0))
draw = ImageDraw.Draw(txt)
font_size=16
font = ImageFont.truetype("DejaVuSansMono.ttf", font_size, encoding='utf-8')
for desc in desc_info:
tempDesc = desc['desc']
x, y = (int(19.20 * desc['locx']), int(10.80 * desc['locy']))
# Too much dark method, as long as some hard code here.
# w, h = font.getsize(str([' ' for i in range(0, int(desc['maxLineCount']))]))
#w, h = font.getsize(str(['s' for i in range(0, 50)])[:int(desc['maxLineCount'] * 3.6)])
#e=font.getsize('ssdfasdf')
w=desc['maxLineCount']*10
h=font_size
rectangleoffset = 6
draw.rectangle(
(x - rectangleoffset, y - rectangleoffset, x + rectangleoffset + w,
y + rectangleoffset*2 + h * desc['line']),
fill=(30, 30, 21, 130))
draw.text((x, y), tempDesc, fill=(255, 255, 255, 100),
font=font)
result = Image.alpha_composite(img, txt)
result.save('bing.jpg')
def main():
parser = argparse.ArgumentParser(description="Draw text on JPEG.")
parser.add_argument(
'input_image_file',
help='File name of input image. The image must be in JPEG format.',
type=str,
)
parser.add_argument(
'text',
help='Text for insert to image.',
type=str,
)
parser.add_argument(
'-of',
'--output_file',
help='Output image file name. default is "${input_image_file}_drawtext.jpg".',
type=str,
)
parser.add_argument(
'-ff',
'--font_file',
help='Font file name for text. default is "NotoSerifCJKjp-Black.otf".',
type=str,
)
parser.add_argument(
'-fs',
'--font_size',
help='Font size for text. default is 50.',
type=int,
default=50,
)
parser.add_argument(
'-sw',
'--stroke_width',
help='Stroke width for text. default is 3.',
type=int,
default=3,
)
parser.add_argument(
'-sp',
'--spacing',
help='Spacing for text line. default is 0.',
type=int,
default=0,
)
parser.add_argument(
'-al',
'--align',
help='Align for text. default is "center".',
type=str,
default="center",
)
parser.add_argument(
'-fc',
'--font_color',
help='Font color for text. default is "#FFFF00".',
type=str,
default="#FFFF00",
)
parser.add_argument(
'-sc',
'--stroke_color',
help='Stroke color for text. default is "#000000".',
type=str,
default="#000000",
)
parser.add_argument(
'-rc',
'--rect_color',
help='Rect color for background of font. default is "#FFFFFF80".',
type=str,
default="#FFFFFF80",
)
args = parser.parse_args()
input_image_file = args.input_image_file
text = args.text
stroke_width = args.stroke_width
spacing = args.spacing
align = args.align
font_color = args.font_color
stroke_color = args.stroke_color
rect_color = args.rect_color
black_color = (0, 0, 0)
yellow_color = (255, 255, 25)
rect_fill_white_color = (255, 255, 255, 128)
# set font
font_file = args.font_file
font_size = args.font_size
if font_file is None:
absolute_path = pathlib.Path(__file__).resolve()
script_dir_path = absolute_path.parent
font_file = str(
script_dir_path.joinpath(
"NotoSerifCJKjp-Black.otf",
)
)
font = ImageFont.truetype(
font_file,
font_size,
)
# Declare output file name.
output_file = args.output_file
if output_file is None:
p_file = pathlib.Path(input_image_file)
p_dir = p_file.parent
suffix = p_file.suffix
stem = p_file.stem
output_file = p_dir.joinpath(
stem + "_drawtext" + suffix,
)
## import image
img = Image.open(input_image_file).copy()
text_draw = ImageDraw.Draw(img)
# get text_size
text_size = text_draw.textsize(
text,
font=font,
stroke_width=stroke_width,
spacing=spacing,
)
# get text_position
text_position_x = int(img.size[0] / 2 - text_size[0] / 2)
text_position_y = int(img.size[1] / 2 - text_size[1] / 2)
text_position = (text_position_x, text_position_y)
# get rect position
rect_position = (
0,
text_position[1],
img.size[0],
text_position[1] + text_size[1]
)
# draw rectangle
img_alpha = img.convert('RGBA')
rectangle_alpha = Image.new('RGBA', img.size)
rectangle_draw = ImageDraw.Draw(rectangle_alpha)
rectangle_draw.rectangle(rect_position, fill=rect_color)
img = Image.alpha_composite(img_alpha, rectangle_alpha)
img = img.convert("RGB")
# draw text
text_draw = ImageDraw.Draw(img)
text_draw.text(
text_position,
text,
font=font,
fill=font_color,
stroke_width=stroke_width,
stroke_fill=stroke_color,
align=align,
spacing=spacing,
)
img.save(output_file)
async def seasoncreate(self, data, seasondata, season, profile,
seasonname):
font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
operator = random.choice(self.bgs)
bg_image = Image.open(
f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")
profile_image = Image
profile_avatar = BytesIO()
profile_url = data.avatar_url_256
async with self.session.get(profile_url) as r:
profile_img = await r.content.read()
profile_avatar = BytesIO(profile_img)
profile_image = Image.open(profile_avatar).convert("RGBA")
# set canvas
bg_color = (255, 255, 255, 0)
result = Image.new("RGBA", (1600, 1080), bg_color)
process = Image.new("RGBA", (1600, 1080), bg_color)
# draw
draw = ImageDraw.Draw(process)
# puts in background
bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
bg_image = bg_image.crop((0, 0, 1920, 1080))
result.paste(bg_image, (0, 0))
aviholder = self.add_corners(
Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
process.paste(aviholder, (1295, 15), aviholder)
process.paste(profile_image, (1300, 20))
# op badge
if season >= 14:
ranks = self.ranksember
else:
ranks = self.ranks
url = self.rankurl + ranks[seasondata["rank_text"]]
process.paste(aviholder, (995, 15), aviholder)
im = Image.open(BytesIO(await self.getimg(url)))
im = im.resize((256, 256), Image.ANTIALIAS)
process.paste(im, (1000, 20))
# data
# draw.text((440, 40), "Name: {}".format(self._truncate_text(data.username, 18)), fill=(255, 255, 255, 255), font=header_fnt)
draw.text(
(
self._center(
440,
1000,
"Name: {}".format(self._truncate_text(data.username, 18)),
header_fnt,
),
40,
),
"Name: {}".format(self._truncate_text(data.username, 18)),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(
self._center(440, 1000, "Platform: {}".format(
str(data.platform).title()), header_fnt),
90,
),
"Platform: {}".format(str(data.platform).title()),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(
self._center(
440, 1000, "Region: {}".format(
self.regions[seasondata["region"]]), header_fnt),
140,
),
"Region: {}".format(self.regions[seasondata["region"]]),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(self._center(440, 1000, f"{seasonname} Statistics",
header_fnt), 190),
f"{seasonname} Statistics",
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(520, 320),
"Games Played: {}".format(seasondata["wins"] +
seasondata["losses"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 380),
"Wins: {}".format(seasondata["wins"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(960, 380),
"Losses: {}".format(seasondata["losses"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 440),
"Abandons: {}".format(seasondata["abandons"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
try:
wlr = round(
seasondata["wins"] /
(seasondata["wins"] + seasondata["losses"]), 2)
except ZeroDivisionError:
wlr = 0
draw.text(
(960, 440),
"Total W/LR: {}%".format(wlr * 100),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 520),
"Kills: {}".format(seasondata["kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(960, 520),
"Deaths: {}".format(seasondata["deaths"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 580),
"MMR: {}".format(seasondata["mmr"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 640),
"Max MMR: {}".format(seasondata["max_mmr"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 700),
"Previous Rank MMR: {}".format(seasondata["prev_rank_mmr"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 760),
"Next Rank MMR: {}".format(seasondata["next_rank_mmr"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 820),
"Rank: {}".format(seasondata["rank_text"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
if seasondata["rank_text"] == "Champions":
draw.text(
(960, 820),
"Champion Rank Position: {}".format(
seasondata["champions_rank_position"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 880),
"Max Rank: {}".format(seasondata["max_rank_text"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
result = Image.alpha_composite(result, process)
file = BytesIO()
result.save(file, "png")
file.name = f"season-{data.username}.png"
file.seek(0)
image = discord.File(file)
return image
print("Imposing heatmap over map")
#impose heatmap over map image
top = Image.open('images/heatmap.png')
bottom = map.mapImage
top = top.convert("RGBA")
top.putalpha(128)
datas = top.getdata()
newData = []
colormap = matplotlib.cm.get_cmap(colormap)
rgba = colormap(0.0)
rgba = (int(rgba[0] * 255), int(rgba[1] * 255), int(rgba[2] * 255),
int(rgba[3] * 255))
for item in datas:
if item[0] == rgba[0] and item[1] == rgba[1] and item[2] == rgba[2]:
newData.append((255, 255, 255, 0))
else:
newData.append(item)
top.putdata(newData)
bottom = bottom.convert("RGBA")
bottom.putalpha(255)
top = top.resize(bottom.size)
final = Image.alpha_composite(bottom, top)
final = final.convert("RGB")
if len(sys.argv) > 3:
final.save("images/" + sys.argv[3])
else:
final.show()
def _draw_legend(self, img, marks, rows, position):
legend = Legend(self._config).draw(img.size, position, marks, rows)
return Image.alpha_composite(img, legend)
def apply_watermark(doc):
if not is_image_path(doc.file_url):
return
image_settings = frappe.get_doc("Renovation Image Settings",
"Renovation Image Settings")
if not image_settings.wm_image:
return # No watermark
if doc.file_url == image_settings.wm_image \
or doc.attached_to_doctype == "Renovation Image Settings":
return # dont apply watermark on watermark :p
if not os.path.exists(get_file_path(image_settings.wm_image)):
return # file not found
og_folder = get_watermarks_og_folder_path()
if not os.path.isdir(og_folder):
os.makedirs(og_folder)
extn = get_extension(doc.file_url)
# check if og_folder has doc.name already
# if not copy file_url there
og_file = os.path.join(og_folder, doc.name + '.' + extn)
if not os.path.exists(og_file):
# copy file_url to og_folder
im = Image.open(get_file_path(doc.file_url)).convert("RGBA")
saveImage(im, og_file, extn)
else:
im = Image.open(og_file).convert("RGBA")
wt_im = Image.open(get_file_path(image_settings.wm_image))
wt_w, wt_h = wt_im.size
width, height = im.size
# scale watermark down according to size specified
wm_p = image_settings.wm_percent / 100
wt_size = (cint(width * wm_p), cint(wt_h * width * wm_p / wt_w))
# resize using thumbnail
wt_im.thumbnail(wt_size, Image.ANTIALIAS)
wt_im = wt_im.convert("RGBA")
wt_im_copy = wt_im.copy()
# opacity
# thresh = 200
# fn = lambda x : 255 if x > thresh else 0
# mask = wt_im.convert("L").point(fn, mode='1') # 8-bit per pixel
# mask = mask.convert("L")
# this will have the transparent part a bit dark
wt_im.putalpha(cint(256 * image_settings.wm_opacity / 100))
# wt_im.putalpha(mask)
# wt_pos
pos = image_settings.wm_position
margin = width * image_settings.wm_margin_percent / 100
# calculate lft and top seperately
if "Left" in pos:
lft = margin
elif "Right" in pos:
lft = width - wt_size[0] - margin
else:
lft = (width - wt_size[0]) // 2 # Center
if "Top" in pos:
top = margin
elif "Bottom" in pos:
top = height - wt_size[1] - margin
else:
top = (height - wt_size[1]) // 2
# make wt same size
wt_scaled = Image.new('RGBA', (width, height), (0, 0, 0, 0))
wt_scaled.paste(wt_im, (cint(lft), cint(top)), mask=wt_im_copy)
b = Image.new('RGBA', (width, height), (0, 0, 0, 0))
b = Image.alpha_composite(b, im)
b = Image.alpha_composite(b, wt_scaled)
saveImage(b, get_file_path(doc.file_url), extn)
def ticket_changer(base_img, paste_img, header_color, font_header, font_main,
font_bold, passenger_info):
# я понимаю, что делать функцию с таким колличеством параметров это не есть хорошо, но неужели лучше принять
# всю инфу каким нибудь одним параметром и делить потом ее внутри функции?
# TODO Вообще да, было бы удобно собрать данные по группам хотя бы
# TODO например передавать сюда словарь "данные_о_пассажире", который бы хранил всю информацию,
# TODO которая надо разместить на билете
# TODO А какие-то системные параметры вроде base_img, paste_img, header_color, font_header
# TODO можно оставить и так.
base = Image.open(base_img).convert("RGBA")
paste = Image.open(paste_img).convert("RGBA")
fnt = ImageFont.truetype(font_main, 30)
font_bold = ImageFont.truetype(font_bold, 30)
fnt_small = ImageFont.truetype(font_main, 20)
fnt_small_2 = ImageFont.truetype(font_main, 13)
fnt2 = ImageFont.truetype(font_header, 30)
draw = ImageDraw.Draw(base)
seat = random_seat_generator()
gate = gate_generator()
flight = random_flight_generator()
correct_split = passenger_info['correct_flight'].split(' ')
correct_time = correct_split[2].replace('.', ':')
correct_date = correct_split[1]
boarding = datetime.strptime(correct_time, "%H:%M") - timedelta(minutes=40)
boarding_str = boarding.strftime("%H:%M")
end_of_boarding = datetime.strptime(correct_time,
"%H:%M") - timedelta(minutes=20)
end_of_boarding_str = end_of_boarding.strftime("%H:%M")
passenger = passenger_info['name'] + ' ' + passenger_info['surname']
departure = passenger_info['departure_city'] + airport_generator(
passenger_info['departure_city'])
arrival = passenger_info['destination_city'] + airport_generator(
passenger_info['destination_city'])
draw.polygon(((0, 0), (1009, 0), (1009, 81), (0, 81)),
outline=header_color,
fill=header_color)
base.paste(paste, (0, 0))
base.paste(paste, (743, 0))
txt = Image.new("RGBA", base.size, (255, 255, 255, 0))
d = ImageDraw.Draw(txt)
d.text((250, 25), 'Посадочный талон', font=font_bold, fill=(0, 0, 0, 240))
d.text((550, 29), 'Boarding pass', font=fnt2, fill=(0, 0, 0, 240))
d.text((108, 132), gate, font=fnt, fill=(0, 0, 0, 240))
d.text((108, 210), boarding_str, font=fnt, fill=(0, 0, 0, 240))
d.text((108, 300), end_of_boarding_str, font=fnt, fill=(0, 0, 0, 240))
d.text((332, 125), passenger, font=fnt_small, fill=(0, 0, 0, 240))
d.text((332, 187), departure, font=fnt_small, fill=(0, 0, 0, 240))
d.text((535, 187), arrival, font=fnt_small, fill=(0, 0, 0, 240))
d.text((332, 250), correct_date, font=fnt_small, fill=(0, 0, 0, 240))
d.text((535, 250), correct_time, font=fnt_small, fill=(0, 0, 0, 240))
d.text((332, 310), seat, font=fnt, fill=(0, 0, 0, 240))
d.text((535, 310), flight, font=fnt, fill=(0, 0, 0, 240))
d.text((782, 125), passenger, font=fnt_small_2, fill=(0, 0, 0, 240))
d.text((782, 187), correct_time, font=fnt_small_2, fill=(0, 0, 0, 240))
d.text((782, 250), flight, font=fnt_small_2, fill=(0, 0, 0, 240))
d.text((782, 310), seat, font=fnt_small, fill=(0, 0, 0, 240))
d.text((900, 187), correct_date, font=fnt_small_2, fill=(0, 0, 0, 240))
d.text((900, 250), departure, font=fnt_small_2, fill=(0, 0, 0, 240))
d.text((900, 310), arrival, font=fnt_small_2, fill=(0, 0, 0, 240))
out = Image.alpha_composite(base, txt)
# with open ('temp_ticket.png', 'wb') as f:
# out.save(f, 'png')
temp_file = BytesIO()
out.save(temp_file, 'png')
temp_file.seek(0)
return temp_file
def draw_status_log(status_log: List[LogEntry], *, timezone: datetime.timezone =
datetime.timezone.utc, show_labels: bool = False, num_days: int = 30) -> BytesIO:
row_count = 1 + num_days + show_labels
image, draw = base_image(IMAGE_SIZE * row_count, 1)
# Set consts
day_width = IMAGE_SIZE / (60 * 60 * 24)
day_height = IMAGE_SIZE // row_count
now = datetime.datetime.now(timezone)
time_offset = now.utcoffset().total_seconds() # type: ignore
total_duration = 0.0
if show_labels:
time_offset += 60 * 60 * 24
# Draw status log entries
for status, _, timespan in status_log:
duration: float = timespan.total_seconds()
total_duration += duration
new_time_offset = time_offset + duration
start_x = round(time_offset * day_width)
end_x = round(new_time_offset * day_width)
draw.rectangle(((start_x, 0), (end_x, 1)), fill=COLOURS[status])
time_offset = new_time_offset
# Reshape Image
pixels = numpy.array(image)
# pixels = pixels[:, IMAGE_SIZE:]
pixels = pixels.reshape(row_count, IMAGE_SIZE, 4)
pixels = pixels.repeat(day_height, 0)
image = Image.fromarray(pixels, 'RGBA')
if show_labels:
overlay = Image.new('RGBA', image.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(overlay)
# Set offsets based on font size
font = ImageFont.truetype('res/roboto-bold.ttf', IMAGE_SIZE // int(1.66 * num_days))
text_width, text_height = draw.textsize('\N{FULL BLOCK}' * 2, font=font)
height_offset = (day_height - text_height) // 2
x_offset = text_width
y_offset = day_height
# Add date labels
date = now - datetime.timedelta(seconds=total_duration)
for _ in range(int(total_duration // ONE_DAY) + 2): # 2 because of timezone offset woes
# if weekend draw signifier
if date.weekday() == 5:
draw.rectangle((0, y_offset, IMAGE_SIZE, y_offset + (2 * day_height)), fill=TRANSLUCENT)
# Add date
_, text_height = draw.textsize(date.strftime('%b. %d'), font=font)
draw.text((x_offset, y_offset + height_offset), date.strftime('%b. %d'), font=font, align='left', fill=WHITE)
y_offset += day_height
date += datetime.timedelta(days=1)
# Add timezone label
draw.text((x_offset, height_offset), str(timezone), font=font, align='left', fill='WHITE')
# Add hour lines
for i in range(1, 24):
x_offset = ONE_HOUR * i
colour = WHITE if not i % 6 else OPAQUE
draw.line((x_offset, day_height, x_offset, IMAGE_SIZE), fill=colour, width=DOWNSAMPLE * 4)
image = Image.alpha_composite(image, overlay)
draw = ImageDraw.Draw(image)
# Add time labels
time = start_of_day(now)
for x_offset in (ONE_HOUR * 6, ONE_HOUR * 12, ONE_HOUR * 18):
time += datetime.timedelta(hours=6)
text_width, _ = draw.textsize(time.strftime('%H:00'), font=font)
draw.text((x_offset - (text_width // 2), height_offset), time.strftime('%H:00'), font=font, align='left', fill=WHITE)
return as_bytes(resample(image))
async def operatorstatscreate(self, data, index, profile):
font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
operator = random.choice(self.bgs)
opdata = data.operators[index]
bg_image = Image.open(
f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")
profile_image = Image
profile_avatar = BytesIO()
profile_url = data.avatar_url_256
async with self.session.get(profile_url) as r:
profile_img = await r.content.read()
profile_avatar = BytesIO(profile_img)
profile_image = Image.open(profile_avatar).convert("RGBA")
# set canvas
bg_color = (255, 255, 255, 0)
result = Image.new("RGBA", (1600, 1080), bg_color)
process = Image.new("RGBA", (1600, 1080), bg_color)
# draw
draw = ImageDraw.Draw(process)
# puts in background
bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
bg_image = bg_image.crop((0, 0, 1920, 1080))
result.paste(bg_image, (0, 0))
aviholder = self.add_corners(
Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
process.paste(aviholder, (1295, 15), aviholder)
process.paste(profile_image, (1300, 20))
# op badge
url = opdata["badge_image"]
process.paste(aviholder, (995, 15), aviholder)
im = Image.open(BytesIO(await self.getimg(url)))
im = im.resize((256, 256), Image.ANTIALIAS)
process.paste(im, (1000, 20))
# data
# draw.text((440, 40), "Name: {}".format(self._truncate_text(data.username, 18)), fill=(255, 255, 255, 255), font=header_fnt)
draw.text(
(
self._center(
440,
1000,
"Name: {}".format(self._truncate_text(data.username, 18)),
header_fnt,
),
40,
),
"Name: {}".format(self._truncate_text(data.username, 18)),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(
self._center(440, 1000, "Platform: {}".format(
str(data.platform).title()), header_fnt),
90,
),
"Platform: {}".format(str(data.platform).title()),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(self._center(440, 1000, f"{opdata['name']} Statistics",
header_fnt), 140),
f"{opdata['name']} Statistics",
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(520, 320),
"Games Played: {}".format(opdata["wins"] + opdata["losses"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text((520, 380),
"Wins: {}".format(opdata["wins"]),
fill=(255, 255, 255, 255),
font=name_fnt)
draw.text(
(920, 380),
"Losses: {}".format(opdata["losses"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
try:
wlr = round(opdata["wins"] / (opdata["wins"] + opdata["losses"]),
2)
except ZeroDivisionError:
wlr = 0
draw.text(
(520, 440),
"Total W/LR: {}%".format(wlr * 100),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 520),
"Kills: {}".format(opdata["kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 520),
"Deaths: {}".format(opdata["deaths"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text((520, 580),
"KDR: {}".format(opdata["kd"]),
fill=(255, 255, 255, 255),
font=name_fnt)
draw.text(
(520, 640),
"Headshots: {}".format(opdata["headshots"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
y = 760
for ability in opdata["abilities"]:
draw.text(
(520, y),
"{}: {}".format(ability["ability"], ability["value"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
y += 80
m, _ = divmod(opdata["playtime"], 60)
h, m = divmod(m, 60)
d, h = divmod(h, 24)
draw.text(
(520, 700),
f"Playtime: {d:d}d {h:d}h {m:02d}m",
fill=(255, 255, 255, 255),
font=name_fnt,
)
result = Image.alpha_composite(result, process)
result = result.crop((500, 0, 1600, 1080))
file = BytesIO()
result.save(file, "png")
file.name = f"operator-{data.username}.png"
file.seek(0)
image = discord.File(file)
return image
async def profilecreate(self, data):
font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
operator = random.choice(self.bgs)
bg_image = Image.open(
f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")
profile_image = Image
profile_avatar = BytesIO()
profile_url = data.avatar_url_256
async with self.session.get(profile_url) as r:
profile_img = await r.content.read()
profile_avatar = BytesIO(profile_img)
profile_image = Image.open(profile_avatar).convert("RGBA")
# set canvas
bg_color = (255, 255, 255, 0)
result = Image.new("RGBA", (1280, 1080), bg_color)
process = Image.new("RGBA", (1280, 1080), bg_color)
# draw
draw = ImageDraw.Draw(process)
# puts in background
bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
bg_image = bg_image.crop((0, 0, 1920, 1080))
result.paste(bg_image, (0, 0))
aviholder = self.add_corners(
Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
process.paste(aviholder, (995, 15), aviholder)
process.paste(profile_image, (1000, 20))
# data
draw.text(
(
self._center(
440,
1000,
"Name: {}".format(self._truncate_text(data.username, 18)),
header_fnt,
),
40,
),
"Name: {}".format(self._truncate_text(data.username, 18)),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(
self._center(440, 1000, "Platform: {}".format(
str(data.platform).title()), header_fnt),
90,
),
"Platform: {}".format(str(data.platform).title()),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(self._center(440, 1000, "General Statistics", header_fnt), 140),
"General Statistics",
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(self._center(1000, 1256, f"Level: {data.level}",
header_fnt), 300),
f"Level: {data.level}",
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(520, 400),
"Wins: {}".format(data.general_stats["wins"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 400),
"Losses: {}".format(data.general_stats["losses"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 470),
"Draws: {}".format(data.general_stats["draws"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 470),
"Total W/LR: {}%".format(
round(
data.general_stats["wins"] /
data.general_stats["games_played"], 2) * 100),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 540),
"Lootbox %: {}%".format(data.lootbox_probability),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 610),
"Kills: {}".format(data.general_stats["kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 610),
"Deaths: {}".format(data.general_stats["deaths"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 680),
"Assists: {}".format(data.general_stats["assists"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 680),
"KDR: {}".format(data.general_stats["kd"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 750),
"Revives: {}".format(data.general_stats["revives"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 750),
"Suicides: {}".format(data.general_stats["suicides"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 820),
"Blind Kills: {}".format(data.general_stats["blind_kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 820),
"Melee Kills: {}".format(data.general_stats["melee_kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 890),
"Pentration Kills: {}".format(
data.general_stats["penetration_kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 890),
"DBNOs: {}".format(data.general_stats["dbnos"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
m, _ = divmod(data.general_stats["playtime"], 60)
h, m = divmod(m, 60)
d, h = divmod(h, 24)
draw.text(
(520, 1010),
f"Playtime: {d:d}d {h:d}h {m:02d}m",
fill=(255, 255, 255, 255),
font=name_fnt,
)
result = Image.alpha_composite(result, process)
file = BytesIO()
result.save(file, "png")
file.name = f"general-{data.username}.png"
file.seek(0)
image = discord.File(file)
return image
def img_bottom_text_draw(pic_obj, exif):
# get an image
base_img = pic_obj.convert("RGBA")
total_size = (base_img.size[0] + 20, base_img.size[1] + 40)
base_layer = pillowImage.new("RGBA", total_size, (255, 255, 255, 0))
# 计算位置和大小
base_img_position = (10, 10)
# draw logo
base_layer.paste(base_img, box=base_img_position)
# make a blank image for the text, initialized to transparent text color
text_layer = pillowImage.new("RGBA", total_size, (255, 255, 255, 0))
# get a font
font_size = 19
font_name = "NotoSansHans-Light.otf"
# font_name = "NotoSansHans-Thin-Windows.otf"
# font_name ="点点像素体-方形.ttf"
text_font = ImageFont.truetype(font_name, font_size)
# get a drawing context
draw_obj = ImageDraw.Draw(text_layer)
# set text color
text_color = (
0 # R
,
0 # G
,
0 # B
,
255) # A
# draw date
photo_date = exif['Exif.Photo.DateTimeOriginal'].split(" ")[0].replace(
":", "-")
text_position = TextPosition.TextPosition("r", 10, "b", 10, 4, "right")
text_xy = text_position.position(text_layer, photo_date, text_font)
draw_obj.text(text_xy,
photo_date,
font=text_font,
fill=text_color,
align="right")
# draw film type
film = exif["Exif.Photo.UserComment"][14:]
text_position = TextPosition.TextPosition("m", 0, "b", 10, 4, "center")
text_xy = text_position.position(text_layer, film, text_font)
draw_obj.text(text_xy,
film,
font=text_font,
fill=text_color,
align="center")
# draw Camera
camera = exif["Exif.Image.Model"]
text_position = TextPosition.TextPosition("l", 10, "b", 10, 4, "right")
text_xy = text_position.position(text_layer, camera, text_font)
draw_obj.text(text_xy,
camera,
font=text_font,
fill=text_color,
align="right")
# 后处理，与原始图像合并再转回RGB
out = pillowImage.alpha_composite(base_layer, text_layer)
out_jpg = out.convert('RGB')
return out_jpg
def add_watermark(input_image_path,
watermark,
text=True,
fntsize=30,
watermark_width=150,
position='center',
location_min=0.25,
location_max=0.75,
alpha_composite=True,
alpha=0.25,
val=False):
val_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224)])
if text: # watermark is a string
# get an image
base = Image.open(input_image_path).convert("RGBA")
# make a blank image for the text, initialized to transparent text color
txt = Image.new("RGBA", base.size, (255,255,255,0))
# get a font
fnt = ImageFont.truetype("fonts/FreeMonoBold.ttf", fntsize)
# get a drawing context
d = ImageDraw.Draw(txt)
# draw text, half opacity
if position == 'center':
w = int(base.size[0]*0.5)
h = int(base.size[1]*0.5)
d.text((w, h), watermark, font=fnt, fill=(0,0,0,128), anchor='mm')
elif position == 'multiple':
for w in [int(base.size[0]*i) for i in [0.25, 0.5, 0.75]]:
for h in [int(base.size[1]*i) for i in [0.25, 0.5, 0.75]]:
d.text((w, h), watermark, font=fnt, fill=(0,0,0,128), anchor='mm')
elif position == 'random':
w = random.randint(int(base.size[0]*0.25), int(base.size[0]*0.75))
h = random.randint(int(base.size[1]*0.25), int(base.size[1]*0.75))
d.text((w, h), watermark, font=fnt, fill=(0,0,0,128), anchor='mm')
else:
logging.info("Invalid position argument")
return
out = Image.alpha_composite(base, txt)
out = out.convert("RGB")
# out.show()
return out
else: # watermark is an RGB image
if alpha_composite:
img_watermark = Image.open(watermark).convert('RGBA')
base_image = Image.open(input_image_path).convert('RGBA')
if val:
# preprocess validation images
base_image = val_transform(base_image)
# watermark = Image.open(watermark_image_path)
width, height = base_image.size
# let's say pasted watermark is 150 pixels wide
# w_width, w_height = img_watermark.size
w_width, w_height = watermark_width, int(img_watermark.size[1]*watermark_width/img_watermark.size[0])
img_watermark = img_watermark.resize((w_width, w_height))
transparent = Image.new('RGBA', (width, height), (0,0,0,0))
# transparent.paste(base_image, (0, 0))
if position == 'center':
location = (int((width - w_width)/2), int((height - w_height)/2))
# location = (450, 100)
# print(location)
transparent.paste(img_watermark, location)
# transparent.show()
# use numpy
na = np.array(transparent).astype(np.float)
# Halve all alpha values
# na[..., 3] *=0.5
transparent = Image.fromarray(na.astype(np.uint8))
# transparent.show()
# change alpha of base image at corresponding locations
na = np.array(base_image).astype(np.float)
# Halve all alpha values
# location = (max(0, min(location[0], na.shape[1])), max(0, min(location[1], na.shape[0]))) # if location is negative, clip at 0
# TODO: Aniruddha I ensure that left upper location will never be negative. So I removed clipping.
na[..., 3][location[1]: (location[1]+w_height), location[0]: (location[0]+w_width)] *=alpha
base_image = Image.fromarray(na.astype(np.uint8))
# base_image.show()
transparent = Image.alpha_composite(transparent, base_image)
elif position == 'multiple':
na = np.array(base_image).astype(np.float)
for w in [int(base_image.size[0]*i) for i in [0.25, 0.5, 0.75]]:
for h in [int(base_image.size[1]*i) for i in [0.25, 0.5, 0.75]]:
location = (int(w - w_width/2), int(h - w_height/2))
transparent.paste(img_watermark, location)
# change alpha of base image at corresponding locations
# Halve all alpha values
location = (max(0, min(location[0], na.shape[1])), max(0, min(location[1], na.shape[0]))) # if location is negative, clip at 0
na[..., 3][location[1]: (location[1]+w_height), location[0]: (location[0]+w_width)] *=alpha
base_image = Image.fromarray(na.astype(np.uint8))
# use numpy
na = np.array(transparent).astype(np.float)
# Halve all alpha values
# na[..., 3] *=0.5
transparent = Image.fromarray(na.astype(np.uint8))
# transparent.show()
# base_image.show()
transparent = Image.alpha_composite(transparent, base_image)
elif position == 'random':
# print(base_image.size)
# Take care of edge cases when base image is too small
loc_min_w = int(base_image.size[0]*location_min)
loc_max_w = int(base_image.size[0]*location_max - w_width)
if loc_max_w<loc_min_w:
loc_max_w = loc_min_w
loc_min_h = int(base_image.size[1]*location_min)
loc_max_h = int(base_image.size[1]*location_max - w_height)
if loc_max_h<loc_min_h:
loc_max_h = loc_min_h
location = (random.randint(loc_min_w, loc_max_w),
random.randint(loc_min_h, loc_max_h))
# print(position)
transparent.paste(img_watermark, location)
# transparent.show()
# use numpy
na = np.array(transparent).astype(np.float)
# Halve all alpha values
# na[..., 3] *=0.5
transparent = Image.fromarray(na.astype(np.uint8))
# transparent.show()
# change alpha of base image at corresponding locations
na = np.array(base_image).astype(np.float)
# Halve all alpha values
# location = (max(0, min(location[0], na.shape[1])), max(0, min(location[1], na.shape[0]))) # if location is negative, clip at 0
# TODO: Aniruddha I ensure that left upper location will never be negative. So I removed clipping.
na[..., 3][location[1]: (location[1]+w_height), location[0]: (location[0]+w_width)] *= alpha
base_image = Image.fromarray(na.astype(np.uint8))
# base_image.show()
transparent = Image.alpha_composite(transparent, base_image)
else:
logging.info("Invalid position argument")
return
transparent = transparent.convert('RGB')
# transparent.show()
if val:
return transparent
else:
return transparent, location, (w_width, w_height)
else: # pasting
img_watermark = Image.open(watermark).convert('RGBA')
base_image = Image.open(input_image_path)
# watermark = Image.open(watermark_image_path)
width, height = base_image.size
# let's say pasted watermark is 150 pixels wide
# w_width, w_height = img_watermark.size
w_width, w_height = watermark_width, int(img_watermark.size[1]*watermark_width/img_watermark.size[0])
img_watermark = img_watermark.resize((w_width, w_height))
transparent = Image.new('RGBA', (width, height), (0,0,0,0))
transparent.paste(base_image, (0, 0))
if position == 'center':
location = (int((width - w_width)/2), int((height - w_height)/2))
transparent.paste(img_watermark, location, mask=img_watermark)
elif position == 'multiple':
for w in [int(base_image.size[0]*i) for i in [0.25, 0.5, 0.75]]:
for h in [int(base_image.size[1]*i) for i in [0.25, 0.5, 0.75]]:
location = (int(w - w_width/2), int(h - w_height/2))
transparent.paste(img_watermark, location, mask=img_watermark)
elif position == 'random':
location = (random.randint(int(base_image.size[0]*0.25 - w_width/2), int(base_image.size[0]*0.75 - w_width/2)),
random.randint(int(base_image.size[1]*0.25 - w_height/2), int(base_image.size[1]*0.75 - w_height/2)))
transparent.paste(img_watermark, location, mask=img_watermark)
else:
logging.info("Invalid position argument")
return
transparent = transparent.convert('RGB')
# transparent.show()
if val:
return transparent
else:
return transparent, location, (w_width, w_height)
def dither_image_to_web_palette(img, bgcolor):
if bgcolor is not None:
# We know the background color so flatten the image and bg color together, thus getting rid of alpha
# This is important because as discussed below, dithering alpha doesn't work correctly.
img = Image.alpha_composite(
Image.new("RGBA", img.size, bgcolor),
img) # alpha blend onto image filled with bgcolor
dithered_img = floydsteinberg_dither_to_web_palette(img)
else:
"""
It is not possible to correctly dither in the presence of transparency without knowing the background
that the image will be composed onto. This is because dithering works by propagating error that is introduced
when we select _available_ colors that don't match the _desired_ colors. Without knowing the final color value
for a pixel, it is not possible to compute the error that must be propagated FROM it. If a pixel is fully or
partially transparent, we must know the background to determine the final color value. We can't even record
the incoming error for the pixel, and then later when/if we know the background compute the full error and
propagate that, because that error needs to propagate into the original color selection decisions for the other
pixels. Those decisions absorb error and are lossy. You can't later apply more error on top of those color
decisions and necessarily get the same results as applying that error INTO those decisions in the first place.
So having established that we could only handle transparency correctly at final draw-time, shouldn't we just
dither there instead of here? Well, if we don't know the background color here we don't know it there either.
So we can either not dither at all if we don't know the bg color, or make some approximation. We've chosen
the latter. We'll handle it here to make the drawing code simpler. So what is our approximation? We basically
just ignore any color changes dithering makes to pixels that have transparency, and prevent any error from being
propagated from those pixels. This is done by setting them all to black before dithering (using an exact-match
color in Floyd Steinberg dithering with a web-safe-palette will never cause a pixel to receive enough inbound error
to change color and thus will not propagate error), and then afterwards we set them back to their original values.
This means that transparent pixels are essentially not dithered - they ignore (and absorb) inbound error but they
keep their original colors. We could alternately play games with the alpha channel to try to propagate the error
values for transparent pixels through to when we do final drawing but it only works in certain cases and just isn't
worth the effort (which involves writing the dithering code ourselves for one thing).
"""
# Force image to RGBA if it isn't already - simplifies the rest of the code
if img.mode != 'RGBA':
img = img.convert('RGBA')
rgb_img = img.convert('RGB')
orig_pixels = img.load()
rgb_pixels = rgb_img.load()
width, height = img.size
for h in range(height): # set transparent pixels to black
for w in range(width):
if (orig_pixels[w, h])[3] != 255:
rgb_pixels[w, h] = (0, 0, 0
) # bashing in a new value changes it!
dithered_img = floydsteinberg_dither_to_web_palette(rgb_img)
dithered_pixels = dithered_img.load() # must do it again
for h in range(height): # restore original RGBA for transparent pixels
for w in range(width):
if (orig_pixels[w, h])[3] != 255:
dithered_pixels[w, h] = orig_pixels[
w, h] # bashing in a new value changes it!
return dithered_img
def make_hourly(self, data, lang):
city = data['city']
temp = str(round(data['temperature'])) + '°'
temp_chart = [
data['temperature'], data['+2'], data['+4'], data['+6'],
data['+8'], data['+10'], data['+12']
]
weather = data['summary'].lower()
wind = str(round(data['wind'])) + messages['ms'][lang]
humidity = str(int(data['humidity'] * 100)) + '%'
feels_like = messages['feels_like'][lang] + str(
round(data['apparentTemperature'])) + '°'
bw_divs = [79, 186, 293, 400, 507, 614, 721]
im = Image.new('RGBA', (800, 656), (255, 255, 255, 0))
bg = Image.open(f'{self.path}/resources/backgrounds/' + data['icon'] +
'.png').convert("RGBA")
card = Image.open(f'{self.path}/resources/card/card.png')
ic = Image.open(f'{self.path}/resources/icons/' + data['icon'] +
'.png')
ic.thumbnail((999, 180), resample=Image.ANTIALIAS)
wind_ic = Image.open(f'{self.path}/resources/icons/wind_ic.png')
hum_ic = Image.open(f'{self.path}/resources/icons/hum_ic.png')
txt = Image.new('RGBA', im.size, (255, 255, 255, 0))
graph = self.make_graph(temp_chart, data['icon'])
font_h = f'{self.path}/resources/fonts/ObjectSans-Heavy.otf'
font_l = f'{self.path}/resources/fonts/ObjectSans-Regular.otf'
temp_font = ImageFont.truetype(font=font_h, size=108)
temp_chart_font_now = ImageFont.truetype(font=font_h, size=25)
temp_chart_font = ImageFont.truetype(font=font_l, size=25)
city_font = ImageFont.truetype(font=font_l, size=32)
feels_like_font = ImageFont.truetype(font=font_l, size=30)
weather_font = ImageFont.truetype(font=font_h, size=43)
weather_font_big = ImageFont.truetype(font=font_h, size=58)
wind_font = ImageFont.truetype(font=font_l, size=29)
time_font = ImageFont.truetype(font=font_l, size=24)
time_font_now = ImageFont.truetype(font=font_h, size=24)
im.paste(bg)
im.paste(ic, (64, 36), ic)
im.paste(card, (0, im.height - card.height), card)
im.paste(graph, (24, im.height - graph.height - 20), graph)
draw = ImageDraw.Draw(txt)
text_size = ImageDraw.Draw(txt).textsize
draw.text((im.width - text_size(city, city_font)[0] - 77, 47),
city,
font=city_font)
draw.text((im.width - text_size(temp, temp_font)[0] - 77, 102),
text=temp,
font=temp_font)
draw.text(
(im.width - text_size(feels_like, feels_like_font)[0] - 77, 197),
text=feels_like,
font=feels_like_font,
fill=(255, 255, 255, 221))
draw.text(((im.width - text_size(wind, wind_font)[0] - 77), 283),
text=wind,
font=wind_font,
fill=(255, 255, 255, 221))
draw.text(((im.width - text_size(humidity, wind_font)[0] - 77), 244),
text=humidity,
font=wind_font,
fill=(255, 255, 255, 221))
im.paste(wind_ic, (im.width - text_size(wind, wind_font)[0] - 77 - 10 -
wind_ic.width, 282), wind_ic)
im.paste(hum_ic, (im.width - text_size(humidity, wind_font)[0] - 77 -
10 - hum_ic.width, 240), hum_ic)
for x in bw_divs:
for y in range(430, im.height - 1):
yl, yc, yr = 0, 0, 0
if im.getpixel((x, y)) == (255, 255, 255, 255):
continue
else:
yc = y
for yy in range(430, im.height - 1):
if im.getpixel((x - 15, yy)) != (255, 255, 255, 255):
yl = yy
break
else:
continue
for yy in range(430, im.height - 1):
if im.getpixel((x + 15, yy)) != (255, 255, 255, 255):
yr = yy
break
else:
continue
if bw_divs.index(x) == 0:
draw.text(
((x + 10 -
text_size(str(temp_chart[bw_divs.index(x)]),
temp_chart_font_now)[0] / 2),
min(yl, yc, yr) - 38),
text=str(round(temp_chart[bw_divs.index(x)])) +
'°',
font=temp_chart_font_now,
fill=(64, 64, 64, 255))
else:
draw.text(
((x + 10 -
text_size(str(temp_chart[bw_divs.index(x)]),
temp_chart_font)[0] / 2),
min(yl, yc, yr) - 38),
text=str(round(temp_chart[bw_divs.index(x)])) +
'°',
font=temp_chart_font,
fill=(64, 64, 64, 221))
break
time = data['time'].split(':')
time_list = list()
time_list.append(data['time'])
hours = time[0]
minutes = time[1]
if int(hours) + 3 > 23:
if int(hours) == 22:
if int(minutes) > 30:
hours = '01'
time[1] = '00'
time_list.append('01:00')
else:
hours = '00'
time[1] = '00'
time_list.append('00:00')
elif int(hours) == 23:
if int(minutes) > 30:
hours = '02'
time[1] = '00'
time_list.append('02:00')
else:
hours = '01'
time[1] = '00'
time_list.append('01:00')
else:
if int(minutes) > 30:
hours = '00'
time[1] = '00'
time_list.append('00:00')
else:
hours = '23'
time[1] = '00'
time_list.append('23:00')
else:
if int(minutes) > 30:
hours = str(int(hours) + 3)
time[0] = hours
time[1] = '00'
time_list.append(':'.join(time))
else:
hours = str(int(hours) + 2)
time[0] = hours
time[1] = '00'
time_list.append(':'.join(time))
for i in range(0, 5):
if int(hours) + 2 > 23:
if int(hours) % 2 == 0:
hours = '00'
else:
hours = '01'
else:
hours = str(int(hours) + 2)
time_plus = [hours, '00']
time_list.append(':'.join(time_plus))
for i in range(0, 7):
if i:
draw.text((bw_divs[i] - text_size(time_list[i])[0], 370),
text=time_list[i],
font=time_font,
fill=(48, 48, 48, 163))
else:
draw.text((bw_divs[i] - text_size(time_list[i])[0], 370),
text=time_list[i],
font=time_font_now,
fill=(64, 64, 64, 255))
lines = textwrap.wrap(weather, width=17)
if len(weather) < 13:
draw.text((64, 253), text=lines[0], font=weather_font_big)
else:
if len(lines) > 2:
liness = textwrap.wrap(weather, width=23)
draw.text((64, 230),
text=liness[0],
font=ImageFont.truetype(font=font_h, size=32))
try:
draw.text(
(64, text_size(liness[0], weather_font)[1] + 230 + 3),
text=liness[1],
font=ImageFont.truetype(font=font_h, size=32))
except:
pass
try:
draw.text(
(64,
text_size(liness[0], weather_font)[1] * 2 + 230 + 3),
text=liness[2],
font=ImageFont.truetype(font=font_h, size=32))
except:
pass
elif len(lines) > 1:
draw.text((64, 245), text=lines[0], font=weather_font)
draw.text((64, text_size(lines[0], weather_font)[1] + 245 + 5),
text=lines[1],
font=weather_font)
else:
draw.text((64, 253), text=lines[0], font=weather_font)
im = Image.alpha_composite(im, txt)
im.show()
bio = BytesIO()
bio.name = 'image.png'
im.save(bio, 'png')
bio.seek(0)
return bio
async def casualstatscreate(self, data):
font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
operator = random.choice(self.bgs)
bg_image = Image.open(
f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")
profile_image = Image
profile_avatar = BytesIO()
profile_url = data.avatar_url_256
async with self.session.get(profile_url) as r:
profile_img = await r.content.read()
profile_avatar = BytesIO(profile_img)
profile_image = Image.open(profile_avatar).convert("RGBA")
# set canvas
bg_color = (255, 255, 255, 0)
result = Image.new("RGBA", (1280, 1080), bg_color)
process = Image.new("RGBA", (1280, 1080), bg_color)
# draw
draw = ImageDraw.Draw(process)
# puts in background
bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
bg_image = bg_image.crop((0, 0, 1920, 1080))
result.paste(bg_image, (0, 0))
aviholder = self.add_corners(
Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
process.paste(aviholder, (995, 15), aviholder)
process.paste(profile_image, (1000, 20))
# data
# draw.text((440, 40), "Name: {}".format(self._truncate_text(data.username, 18)), fill=(255, 255, 255, 255), font=header_fnt)
draw.text(
(
self._center(
440,
1000,
"Name: {}".format(self._truncate_text(data.username, 18)),
header_fnt,
),
40,
),
"Name: {}".format(self._truncate_text(data.username, 18)),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(
self._center(440, 1000, "Platform: {}".format(
str(data.platform).title()), header_fnt),
90,
),
"Platform: {}".format(str(data.platform).title()),
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(self._center(440, 1000, "Alltime Ranked Statistics",
header_fnt), 140),
"Alltime Casual Statistics",
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(self._center(1000, 1256, f"Level: {data.level}",
header_fnt), 300),
f"Level: {data.level}",
fill=(255, 255, 255, 255),
font=header_fnt,
)
draw.text(
(520, 400),
"Games Played: {}".format(
data.queue_stats["casual"]["games_played"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 480),
"Wins: {}".format(data.queue_stats["casual"]["wins"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 480),
"Losses: {}".format(data.queue_stats["casual"]["losses"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 560),
"Draws: {}".format(data.queue_stats["casual"]["draws"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
try:
wlr = (round(
data.queue_stats["casual"]["wins"] /
data.queue_stats["casual"]["games_played"],
2,
) * 100)
except ZeroDivisionError:
wlr = 0
draw.text((520, 640),
"Total W/LR: {}%".format(wlr),
fill=(255, 255, 255, 255),
font=name_fnt)
draw.text(
(520, 800),
"Kills: {}".format(data.queue_stats["casual"]["kills"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(920, 800),
"Deaths: {}".format(data.queue_stats["casual"]["deaths"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
draw.text(
(520, 880),
"KDR: {}".format(data.queue_stats["casual"]["kd"]),
fill=(255, 255, 255, 255),
font=name_fnt,
)
m, _ = divmod(data.queue_stats["casual"]["playtime"], 60)
h, m = divmod(m, 60)
d, h = divmod(h, 24)
draw.text(
(520, 960),
f"Playtime: {d:d}d {h:d}h {m:02d}m",
fill=(255, 255, 255, 255),
font=name_fnt,
)
result = Image.alpha_composite(result, process)
file = BytesIO()
result.save(file, "png")
file.name = f"casual-{data.username}.png"
file.seek(0)
image = discord.File(file)
return image
if os.path.isdir(os.path.join(config.EYES_DIR, dir)):
eyes[dir] = []
print(dir)
for infile in glob.glob(os.path.join(config.EYES_DIR, dir, '*.tga')):
eyes[dir].append(Image.open(infile).convert('RGBA'))
if dir.islower():
eyes['default'].append(Image.open(infile).convert('RGBA'))
print('Eyes OK')
#Create new flags
for key in flags:
print("Creating %s flag." % key)
#add eyes to image
i = Image.alpha_composite(
flags[key], eyes['default'][randint(0,
len(eyes['default']) - 1)])
#add shadow to image
o = Image.alpha_composite(i, shw)
print("Saving %s" % os.path.join(config.OUTPUT_DIR, key + ".tga"))
#save image
o.save(os.path.join(config.OUTPUT_DIR, key + ".tga"))
#If culture filter is on check to see if it fits the criteria
if config.use_culture:
for filter in config.culture_filters:
for ct in config.culture_filters[filter]:
#Ignore rebels
if key.isupper():
#Separate culture and culture groups
if ct.islower():
async def profile(self, ctx: aoi.AoiContext, member: discord.Member = None):
member = member or ctx.author
try:
_, _, _, _, bg = await self.bot.db.get_badges_titles(member)
if not bg:
card_bg = self.default_bg.copy()
else:
_buf = io.BytesIO()
async with aiohttp.ClientSession() as sess:
async with sess.get(bg) as resp:
resp.raise_for_status()
_buf.write(await resp.content.read())
_buf.seek(0)
card_bg = Im.open(_buf)
card_bg = crop_max_square(card_bg)
card_bg = card_bg.resize((512, 512))
except Exception as error: # noqa
card_bg = self.default_bg.copy()
traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)
card_bg = card_bg.convert("RGBA")
await self.bot.db.ensure_xp_entry(member)
global_xp = self.bot.db.global_xp[member.id]
server_xp = self.bot.db.xp[ctx.guild.id][member.id]
global_level, global_rem = _level(global_xp)
server_level, server_rem = _level(server_xp)
avatar_buf = io.BytesIO()
await member.avatar.save(avatar_buf)
avatar_buf.seek(0)
img = self.background.copy()
avatar_img = Im.open(avatar_buf)
avatar_img = avatar_img.resize((128, 128))
img_draw = Dw.Draw(img)
img.paste(avatar_img, (32, 32))
avatar_buf.close()
# create overlays for the xp bars
global_width = 330.66672 * global_rem / _xp_per_level(global_level + 1)
global_xp_poly = (133.33328, 192), \
(133.33328 + global_width, 192), \
(117.33328 + global_width, 240), \
(117.33328, 240)
server_width = 330.66672 * server_rem / _xp_per_level(server_level + 1)
server_xp_poly = (112, 256), \
(112 + server_width, 256), \
(96 + server_width, 304), \
(96, 304)
overlay = Im.new("RGBA", img.size, (0, 0, 0, 0))
Dw.Draw(overlay).polygon(global_xp_poly, fill=(0, 0, 0) + (120,))
Dw.Draw(overlay).polygon(server_xp_poly, fill=(0, 0, 0) + (120,))
img = PIL.Image.alpha_composite(img, overlay)
img_draw = Dw.Draw(img)
# draw text
await self.bot.db.ensure_user_entry(member)
x, y, _, _, sz = _center_and_fit(454, 162, 190, 111, (await self.bot.db.get_titles(member))[0], 32, img_draw,
w_pad=24)
img_draw.text((x, y), (await self.bot.db.get_titles(member))[0], font=_font(sz))
x, y, _, _, sz = _center_and_fit(217.6, 80, 480, 32, member.name, 32, img_draw,
w_pad=24)
img_draw.text((x, y), member.name, font=_font(sz))
x, y, _, _, sz = _center_and_fit(115.8, 191, 480, 242,
f"Level {global_level} - # {self._get_global_rank(member)}",
32, img_draw, w_pad=24)
img_draw.text((x, y), f"Level {global_level} - # {self._get_global_rank(member)}",
font=_font(sz))
x, y, _, _, sz = _center_and_fit(95, 255, 459.2, 306,
f"Level {server_level} - # {self._get_rank(member)}",
32, img_draw, w_pad=24)
img_draw.text((x, y), f"Level {server_level} - # {self._get_rank(member)}",
font=_font(sz))
x, y, _, _, sz = _center_and_fit(115.8, 319, 257.5, 370,
f"{_cur_string(await self.bot.db.get_global_currency(member))}",
32, img_draw, w_pad=24)
img_draw.text((x, y), f"{_cur_string(await self.bot.db.get_global_currency(member))}",
font=_font(sz))
x, y, _, _, sz = _center_and_fit(94.5, 383, 236.2, 434,
f"{_cur_string(await self.bot.db.get_guild_currency(member))}",
32, img_draw, w_pad=24)
img_draw.text((x, y), f"{_cur_string(await self.bot.db.get_guild_currency(member))}",
font=_font(sz))
card_bg = card_bg.convert("RGBA")
img = Im.alpha_composite(card_bg, img)
buf = io.BytesIO()
img.save(fp=buf, format="png")
buf.seek(0)
await ctx.send(file=(discord.File(buf, "profile.png")))
def image_to_ascii_generator(request):
"""
Generate ascii from image.
:param request: Request with data.
:return: JsonResponse in case of error or dictionary with "file_name", "num_cols", "brightness", "contrast" and "arts".
"""
file_name = request.POST.get('file_name', None)
num_cols = request.POST.get('num_cols', 90)
brightness = request.POST.get('brightness', 100)
contrast = request.POST.get('contrast', 100)
# Validating user's input
try:
brightness = float(brightness) / 100
except:
brightness = 1.
try:
contrast = float(contrast) / 100
except:
contrast = 1.
try:
num_cols = int(num_cols)
except:
num_cols = 90
# if we are in DEBUG = False, restrict num_cols to desired number
NUM_COLS_MAX = 300
if not settings.DEBUG and num_cols > NUM_COLS_MAX:
num_cols = NUM_COLS_MAX
img = request.FILES.get('img', None)
# CACHING
if file_name:
cache_key = '_'.join((
'image_to_ascii_generator',
str(file_name),
str(num_cols),
str(brightness),
str(contrast),
))
response = cache.get(cache_key)
if response:
return response
else:
cache_key = None
if file_name is not None: # If we are already having image saved - just need to re-generate arts
path = os.path.join(settings.TEMPORARY_IMAGES, file_name)
if not os.path.exists(path):
path = os.path.join(settings.MEDIA_ROOT, file_name)
if not os.path.exists(path):
return JsonResponse(
{
'error':
'This image file does not exist or it was deleted from the server.'
},
status=410)
elif img is not None: # If we are uploading new image
# Getting extension of image
unused_fn, file_extension = os.path.splitext(img.name)
# If .bmp or .gif uploaded, convert it to .png
converted_to_png = False
if file_extension in '.bmp .gif':
file_extension = '.png'
converted_to_png = True
# Generating unique full path to image (None if many recursions for some reason)
path, file_name = _generate_unique_image_path(file_extension)
if path is None:
return JsonResponse({}, status=400)
# Trying to open user's image (and convert it if needed)
try:
input_img = Image.open(img)
if converted_to_png:
if file_extension == '.bmp':
input_img = input_img.convert('RGB')
elif file_extension == '.gif':
input_img = input_img.convert("RGBA")
bg = Image.new("RGBA", input_img.size)
input_img = Image.composite(input_img, bg, input_img)
except Exception as error:
# print(error)
return JsonResponse({'error': error.args}, status=400)
# Saving image to defined path with some compression and removing transparency from png
if file_extension == '.png':
try:
image = input_img.convert('RGBA')
background = Image.new('RGBA', image.size, (255, 255, 255))
image = Image.alpha_composite(background, image)
except:
image = input_img
else:
image = input_img
if image.height > 1000 or image.width > 1000:
image.thumbnail((1000, 1000), Image.ANTIALIAS)
image.save(path, optimize=True, quality=95)
else:
return JsonResponse({}, status=400)
# Calculating optimal num_cols for small images
num_cols = _calculate_num_cols(path, num_cols)
# Calling image_to_ascii generators in 2 threads, giving them full path to image and options
args = [path]
kwargs = {
'num_cols': num_cols,
'contrast': contrast,
'brightness': brightness
}
# ---- Thread 1
arts_1_list = [None, None]
kwargs1 = {'mode': 'simple'}
kwargs2 = {'mode': 'bars'}
arts_1_thread = threading.Thread(target=_generator_thread_1_hub,
daemon=True,
args=(arts_1_list, args, kwargs, kwargs1,
kwargs2))
arts_1_thread.start()
# ---- Thread 2
arts_2_list = [None, None]
arts_2_thread = threading.Thread(target=_generator_thread_2_hub,
daemon=True,
args=(arts_2_list, args, kwargs))
arts_2_thread.start()
# Converting some options back to percentage
brightness = int(brightness * 100)
contrast = int(contrast * 100)
# ---- Wait Wait for threads to join here
arts_1_thread.join()
arts_2_thread.join()
response = {
'file_name': file_name,
'num_cols': num_cols,
'brightness': brightness,
'contrast': contrast,
'arts': [*arts_1_list, *arts_2_list]
}
# CACHING
if cache_key:
cache.set(cache_key, response, settings.CACHE_TIMEOUT_SHORT)
return response
background_image = background_image.convert("RGBA")
image = Image.new("RGBA", background_image.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(image)
txt1_size = draw.textsize(txt1, font=font)
txt2_size = draw.textsize(txt2, font=font)
draw.text((5, int(image.height - txt1_size[1] - 5)),
txt1,
font=font,
fill=(255, 165, 0, 255))
draw.text((int(image.width - txt2_size[0] - 10),
int(image.height - txt2_size[1] - 5)),
txt2,
font=font,
fill=(255, 165, 0, 255))
if len(sys.argv) > 3:
#paste the other stuff onto the thing.
logo = Image.open(sys.argv[2])
logo.load()
phase = Image.open(sys.argv[3])
phase.load
image.paste(logo, ((int(image.width / 2) - int(logo.width / 2), 18)))
image.paste(phase, ((int(image.width / 2) - int(phase.width / 2)),
int(image.height - phase.height - 30)))
outfile_name = sys.argv[4]
else:
outfile_name = sys.argv[2]
image = Image.alpha_composite(background_image, image)
image.save(outfile_name)
def waterMarkImages(imageFile,
imageOutputPath,
text,
fontName="Bangers",
size="M",
opacity=255,
position="BR"):
# TODO : Try to have color as an argument as well
"""
Watermarks your images based on whatever arguments you've provided.
Args:
imageFile(str): Name of the image file
imageOutputPath(str): Specify the output folder, not the name
fontName(str): Put the path of the font of your choice,
or one of those available
size(str): Size must be in XS, S, M, L, XL, XXL
opacity(int): Opacity must be between 0 and 255 (inclusive)
position(str): Position must be in BR, BL, TR, TL
Returns:
str - Filename of your output file
"""
fileName = imageFile.split(os.path.sep)[-1]
try:
photo = Image.open(imageFile).convert("RGBA")
except IOError:
raise WatermarkException(4, val=imageFile)
width, height = photo.size
COLOR = (255, 255, 255)
textImage = Image.new('RGBA', (width, height), COLOR + (0, ))
fontsize = _setSize(width, height, size)
drawing = ImageDraw.Draw(textImage)
if fontName in FONT_MAP:
# * fontPath = "PyWaterMark\\fonts\\" + FONT_MAP[fontName] - ONLY DEVS
fontPath = pkg_resources.resource_filename(
'PyWatermark', 'fonts/' + FONT_MAP[fontName])
if not os.path.isfile(fontPath):
raise WatermarkException(2, val=fontName)
else:
if not os.path.isfile(fontName):
raise WatermarkException(3, val=fontName)
font = ImageFont.truetype(fontPath, fontsize)
textWidth, textHeight = drawing.textsize(text, font)
pos = _setPosition(width, height, textWidth, textHeight, position)
drawing.text(pos, text, fill=COLOR + (opacity, ), font=font)
combined = Image.alpha_composite(photo, textImage)
filenameSave = fileName.split('.')
filenameSave[1] = 'wm.png'
filenameSave = ''.join(filenameSave)
# * Why you can't store JPEG images with transparency
# * https://stackoverflow.com/questions/41413956/pil-unable-to-change-the-transparency-level-for-jpeg-image
combined.save(imageOutputPath + '\\' + filenameSave)
return filenameSave
def paste_alpha(background, foreground):
return Image.alpha_composite(background, foreground)
def render_map(directory, data_directory, input_):
try:
i = input_['i']
length = input_['length']
eclipse_path_data = input_['eclipse_path_data']
movie_frame = input_['movie_frame']
poly = input_['poly']
poly_dt = input_['poly_dt']
path = input_['path']
path_data = input_['path_data']
# point = path.center_line.interpolate(bin_value, normalized=True)
# bin_lat, bin_lon = point.x, point.y
dpi = 300
width = 321
height = 204
scaled_width = width / float(dpi)
scaled_height = height / float(dpi)
fig = plt.figure(dpi=dpi, figsize=(scaled_width, scaled_height))
map = Basemap(
llcrnrlon=-119.5, llcrnrlat=24.5,
urcrnrlon=-66, urcrnrlat=47,
projection='lcc',
lat_1=33, lat_2=45,
lat_0=39.828, lon_0=-98.579)
base_color = 'white'
border_color = 'black'
boundary_color = 'none'
map.drawmapboundary(color=boundary_color)
# map.plot(path_data[1], path_data[0], color='green', marker='.', markersize=0.0001, latlon=True, zorder=1)
ax = fig.gca()
if movie_frame is not None:
photo_lat = movie_frame[1]
photo_lon = movie_frame[2]
draw_photo_pin(data_directory, ax, map, photo_lon, photo_lat)
draw_eclipse_umbra(ax, map, poly)
fig.subplots_adjust(bottom=0, left=0, right=1, top=1, wspace=0, hspace=0)
plt.tight_layout(pad=0.0, w_pad=0.0, h_pad=0)
# plt.show()
fname = os.path.join(directory, "marker.%05d.png" % i)
fig.savefig(fname, dpi=dpi, transparent=True)
plt.close(fig)
map_fname = os.path.join(data_directory, "Grey_map_withline.png")
im1 = Image.open(map_fname)
im2 = Image.open(fname)
a = 1
b = 0
c = +7 #left/right (i.e. 5/-5)
d = 0
e = 1
f = -7 #up/down (i.e. 5/-5)
im2_tx = im2.transform(im2.size, Image.AFFINE, (a, b, c, d, e, f))
comp = Image.alpha_composite(im1, im2_tx)
fname = os.path.join(directory, "map.%05d.png" % i)
comp.save(fname)
except Exception as e:
print "exception in render_map on", i
traceback.print_exc(limit=50)
def makecomposite(ts, destdir):
date = ts[:8]
time = ts[8:12]
# Put the tiles into a canvas, overlay the map, filet to HD size, then adorn w/ timestamp & logos
compositedir = "%s/%s/%s" % (rootdir, "composite", date)
compositefn = "%s/%s_%s_%s_%s.png" % (compositedir, prefix, urldir, region,
ts)
hdtvdir = "%s/%s/%s" % (rootdir, "hdtv", date)
if reprocess:
hdtvdir = "%s/%s/%s" % (rootdir, "reprocess", date)
hdfn = "%s/%s_%s_%s_%s.png" % (hdtvdir, prefix, urldir, region, ts)
if os.path.isfile(compositefn) and os.path.isfile(hdfn) and not force:
logging.info("Composites Exist: %s %s" % (date, time))
return
if composite and not os.path.exists(compositedir):
os.makedirs(compositedir)
if hdtv and not os.path.exists(hdtvdir):
os.makedirs(hdtvdir)
logging.debug("Reading tiles: %s %s" % (date, time))
base = Image.new('RGBA', (htiles * tilesize, vtiles * tilesize))
for i in range(0, vtiles):
for j in range(0, htiles):
try:
tile = Image.open(
"%s/%03d_%03d.png" %
(destdir, i + voffset, j + hoffset)).convert('RGBA')
except:
logging.warning("Couldn't open %s/%03d_%03d.png" %
(destdir, i + voffset, j + hoffset))
return
base.paste(tile, (j * tilesize, i * tilesize))
# make the map overlay if all map tiles exist
logging.debug("Reading map: %s %s" % (date, time))
try:
fetchmap()
overlay = Image.new('RGBA', (htiles * tilesize, vtiles * tilesize))
for i in range(0, vtiles):
for j in range(0, htiles):
tile = Image.open(
"%s/%03d_%03d.png" %
(mapdir, i + voffset, j + hoffset)).convert('RGBA')
overlay.paste(tile, (j * tilesize, i * tilesize))
base = Image.alpha_composite(base, overlay)
except:
logging.warning("fetchmap failed")
# pass # catch if fetchmap() fails
if composite and not os.path.isfile(compositefn):
logging.info("Composite created: %s" % (compositefn))
base.save(compositefn)
if hdtv:
# Crop to (w x h) @ upper corner (x, y)
# Base image is 2712x2034
# Crop to 16x9 aspect ratio - step is 48x27,(96x54), (192x108), (240x135)
# Sizes might be 2400x1350, 2640x1485, 2688x1512
if goes == "16": # Eastern CONUS, not for hurricanes
x = 150
y = 200
w = 2400
h = 1350
if goes == "17": # Eastern Pacific to watch snow & Hawaii sailing wx
x = 24
y = 180
w = 2688
h = 1512
crop = base.crop((x, y, x + w, y + h))
# crop.load()
hdcanvas = crop.resize((1920, 1080), Image.LANCZOS)
year = ts[0:4]
month = ts[4:6]
day = ts[6:8]
hour = ts[8:10]
minute = ts[10:12]
cfont = ImageFont.truetype("lucon.ttf",
24) # lucida console - cour.ttf is ugly
# getsize() returns for actual string, so figure out the greatest possible font height
x, fheight = cfont.getsize(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_=+[{]}\|;:',<.>/?"
)
tsstring = " GOES-%s %s-%s-%s %s:%sZ " % (goes, year, month, day, hour,
minute)
x = 4
y = 8
ypad = 2
w, h = cfont.getsize(tsstring)
canvas = Image.new('RGBA', hdcanvas.size, (255, 255, 255, 0))
draw = ImageDraw.Draw(canvas)
draw.rectangle(
(x, y, x + w, y + fheight + ypad + ypad),
fill=(0, 0, 0, 0x80)) # Add some Y padding - X is padded w/ spaces
draw.text((x, y + ypad),
tsstring,
fill=(0xff, 0xff, 0xff, 0xff),
font=cfont)
# print ("x%d y%d w%d h%d ypad%d fheight%d" % (x, y, w, h, ypad, fheight))
if goes == "17" and (int(year) < 2019) or ((int(year) == 2019) and
((int(month) < 2) or
((int(month) == 2) and
(int(day) < 12)))):
wstring = " GOES-17 Preliminary, Non-Operational Data "
w, h = cfont.getsize(wstring)
x = hdcanvas.width - (w + x)
draw.rectangle(
(x, y, x + w, y + fheight + ypad + ypad),
fill=(0, 0, 0,
0x80)) # Add some Y padding - X is padded w/ spaces
draw.text((x, y + ypad),
wstring,
fill=(0xff, 0xff, 0xff, 0xff),
font=cfont)
# print ("x%d y%d w%d h%d ypad%d fheight%d" % (x, y, w, h, ypad, fheight))
logoheight = 96.0
logospacing = 4
logomargin = 8
rammb1 = Image.open("rammb_logo.png")
rammblogo = rammb1.resize(
(int(rammb1.width *
(logoheight / rammb1.height)), int(logoheight)),
Image.ANTIALIAS)
x = hdcanvas.width - (rammblogo.width + logomargin)
y = hdcanvas.height - (rammblogo.height + logomargin)
# print("ciralogo %dx%d @ %d, %d" % (rammblogo.width, rammblogo.height, x, y))
hdcanvas.paste(rammblogo, (x, y), rammblogo)
cira1 = Image.open("cira18Logo.png")
ciralogo = cira1.resize(
(int(cira1.width * (logoheight / cira1.height)), int(logoheight)),
Image.ANTIALIAS)
x = x - (ciralogo.width + logospacing)
y = hdcanvas.height - (ciralogo.height + logomargin)
# print("ciralogo %dx%d @ %d, %d" % (ciralogo.width, ciralogo.height, x, y))
hdcanvas.paste(ciralogo, (x, y), ciralogo)
if goes == "16":
l1 = Image.open("goesRDecalSmall.png")
if goes == "17":
l1 = Image.open("GOES-S-Mission-Logo-1024x655.png")
goeslogo = l1.resize(
(int(l1.width * (logoheight / l1.height)), int(logoheight)),
Image.ANTIALIAS)
x = x - (goeslogo.width + logospacing)
y = hdcanvas.height - (goeslogo.height + logomargin)
# print("goeslogo %dx%d @ %d, %d" % (goeslogo.width, goeslogo.height, x, y))
hdcanvas.paste(goeslogo, (x, y), goeslogo)
# afont = ImageFont.truetype("times.ttf", 24)
text = " Image Credits "
w, h = cfont.getsize(text)
x = hdcanvas.width - (w + logomargin)
y = hdcanvas.height - (logoheight + h + logomargin + logospacing +
ypad + ypad)
# print("image credit %dx%d @ %d, %d" % (w, h, x, y))
draw.rectangle((x, y, x + w, y + h), fill=(0, 0, 0, 0x80))
draw.text((x, y + ypad), text, fill=(255, 255, 255, 255), font=cfont)
hdcanvas = Image.alpha_composite(hdcanvas, canvas)
del draw
hdcanvas.save(hdfn)
logging.info("HD created: %s" % (hdfn))
logging.info("rm %s" % (destdir))
shutil.rmtree(destdir)
kp, des = sift.detectAndCompute(gray,None)
temptest, classified_pointstest, meanstest=cv2.kmeans(data=des,K=k_num,bestLabels=None,criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_MAX_ITER, 1000, 0.001),attempts=10,flags=cv2.KMEANS_RANDOM_CENTERS)
meanstest=meanstest.reshape(-1)
test_set.append(meanstest)
test_labels.append(1)
testdata=np.float32(test_set)
responses=np.float32(test_labels)
font=cv2.FONT_HERSHEY_SIMPLEX
im = Image.open("E:\\python\\imagecat\\"+str(i)+".jpg").convert('RGBA')
im=im.resize((250,250))
txt=Image.new('RGBA', im.size, (0,0,0,0))
fnt=ImageFont.truetype("c:/Windows/fonts/Tahoma.ttf", 20)
d=ImageDraw.Draw(txt)
d.text((txt.size[0]-240,txt.size[1]-60), "true label:1",font=fnt, fill=(0,255,0,255))
#d.text((txt.size[0]-120,txt.size[1]-60), "test label:1",font=fnt, fill=(255,0,0,255))
out=Image.alpha_composite(im, txt)
#out.show()
temppath="E:\\python\\testsetdk\\"+"Knum_"+str(k_num)+"i_"+str(testdata.shape[0])+".jpg"
out.save(temppath)
Paths.append(temppath)
except BaseException as error:
print("error")
continue
for i in xrange(10):
try:
img=cv2.imread("E:\\python\\imagemaltese\\"+str(i)+".jpg")
res=cv2.resize(img,(250,250))
gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
sift = cv2.SIFT()
kp, des = sift.detectAndCompute(gray,None)
temptest, classified_pointstest, meanstest=cv2.kmeans(data=des,K=k_num,bestLabels=None,criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_MAX_ITER, 1000, 0.001),attempts=10,flags=cv2.KMEANS_RANDOM_CENTERS)
portraits = get_portraits_img(card_file)
if portraits is None:
# This can happen since JP gets ahead of NA and it's not easy to
# confirm that a card is in JP but not NA
print('skipping {} because CARDS file does not exist: {}'.format(
card_id, card_file))
continue
card_img = get_card_img(portraits, row, col)
if is_entirely_transparent(card_img):
print('skipping {} because it is missing'.format(card_id))
continue
# Create a grey image to overlay the portrait on, filling in the background
grey_img = Image.new("RGBA", card_img.size, color=(68, 68, 68, 255))
card_img = Image.alpha_composite(grey_img, card_img)
attr_img = attr_imgs[card_attr]
# Adjust the card image to fit the portrait
new_card_img = Image.new("RGBA", attr_img.size)
new_card_img.paste(card_img, (2, 2))
# Merge the attribute border on to the portrait
merged_img = Image.alpha_composite(new_card_img, attr_img)
if card_sattr:
sattr_img = sattr_imgs[card_sattr]
# Adjust the subattribute image to the attribute image size
new_sattr_img = Image.new("RGBA", attr_img.size)
# There's a slight offset needed for the subattribute border
class PixCache(object):
def __init__(self):
self._data = {}
def get_pix(self, filename, size=None):
if filename is None:
return None
mimetype = mimetypes.guess_type(filename)[0]
if mimetype is None or not mimetype.startswith("image/"):
return None
if filename not in self._data:
self._data[filename] = {}
if size in self._data[filename]:
pix = self._data[filename][size]
else:
try:
h = hashlib.sha1(('%f%s' % (os.path.getmtime(filename),
filename)).encode()).hexdigest()
tmp_cache_path = GLib.get_user_cache_dir() + '/cs_backgrounds/'
if not os.path.exists(tmp_cache_path):
os.mkdir(tmp_cache_path)
cache_filename = tmp_cache_path + h + "v2"
if os.path.exists(cache_filename):
# load from disk cache
try:
with open(cache_filename, "r") as cache_file:
pix = pickle.load(cache_file)
tmp_img = Image.open(BytesIO(pix[0]))
pix[0] = self._image_to_pixbuf(tmp_img)
except Exception, detail:
print "Failed to load cache file: %s: %s" % (
cache_filename, detail)
pix = None
else:
if mimetype == "image/svg+xml":
# rasterize svg with Gdk-Pixbuf and convert to PIL Image
tmp_pix = GdkPixbuf.Pixbuf.new_from_file(filename)
mode = "RGBA" if tmp_pix.props.has_alpha else "RGB"
img = Image.frombytes(
mode, (tmp_pix.props.width, tmp_pix.props.height),
tmp_pix.read_pixel_bytes().get_data(), "raw", mode,
tmp_pix.props.rowstride)
else:
img = Image.open(filename)
img = apply_orientation(img)
# generate thumbnail
(width, height) = img.size
if img.mode != "RGB":
if img.mode == "RGBA":
bg_img = Image.new("RGBA", img.size,
(255, 255, 255, 255))
img = Image.alpha_composite(bg_img, img)
img = img.convert("RGB")
if size:
img.thumbnail((size, size), Image.ANTIALIAS)
img = imtools.round_image(img, {}, False, None, 3, 255)
img = imtools.drop_shadow(img,
4,
4,
background_color=(255, 255, 255,
0),
shadow_color=0x444444,
border=8,
shadow_blur=3,
force_background_color=False,
cache=None)
# save to disk cache
try:
png_bytes = BytesIO()
img.save(png_bytes, "png")
with open(cache_filename, "w") as cache_file:
pickle.dump([png_bytes.getvalue(), width, height],
cache_file, 2)
except Exception, detail:
print "Failed to save cache file: %s: %s" % (
cache_filename, detail)
def draw_page(self):
# get an image
dir_path = os.path.dirname(os.path.abspath(__file__))
img_path = dir_path + '/assets/stats_h_page.png'
if self.dt_range == 'hour':
img_path = dir_path + '/assets/stats_h_page.png'
elif self.dt_range == 'day':
img_path = dir_path + '/assets/stats_d_page.png'
elif self.dt_range == 'week':
img_path = dir_path + '/assets/stats_w_page.png'
elif self.dt_range == 'month':
img_path = dir_path + '/assets/stats_m_page.png'
elif self.dt_range == 'year':
img_path = dir_path + '/assets/stats_y_page.png'
base = Image.open(img_path).convert('RGBA')
fff = Image.new(base.mode, base.size, (255,) * 4)
img = Image.composite(base, fff, base)
# make a blank image for the text, initialized as transparent
txt = Image.new('RGBA', base.size, (255, 255, 255, 0))
# get a font
font_path = dir_path + '/assets/HaxM-10.pil'
font10 = ImageFont.load(font_path)
font_path = dir_path + '/assets/HaxM-13.pil'
font20 = ImageFont.load(font_path)
# get a drawing context
d = ImageDraw.Draw(txt)
# draw text, full opacity
fname = '/var/www/connectbox/connectbox_default/stats.top10.json'
if os.path.isfile(fname):
# file exists continue
with open(fname) as json_file:
data = json.load(json_file)
y = 0
count = 0
if self.page_num == 1:
d.text((107, 22), 'p1', font=font20, fill="black")
else:
d.text((107, 22), 'p2', font=font20, fill="black")
# check to see if we have data or not
for p in data[self.dt_range]:
if 'resource' in p.keys():
# cover up the unhappy face
d.rectangle((25, 1, 75, 128), fill="white")
for p in data[self.dt_range]:
media = p['resource'].rsplit('/', 1)[1]
if self.page_num == 1:
# trim out directories
d.text((2, y), '(%s) %s' %
(str(p['count']), media),
font=font10, fill="black")
y += 12
count += 1
if count == 5:
break
else:
# trim out directories
count += 1
if count > 5:
d.text((2, y), '(%s) %s' %
(str(p['count']), media),
font=font10, fill="black")
y += 12
out = Image.alpha_composite(img, txt)
self.device.display(out.convert(self.device.mode))
self.device.show()
lst_atypical = [a[1:] for a in lst_atypical]
bg_atyp = random.choice(lst_atypical)
usepath = os.path.join(
'/media/noor/DataNS/Imagesets/SUN/SUN2012/SUN2012', bg_atyp)
for bg_im in os.listdir(
os.path.join(
'/media/noor/DataNS/Imagesets/SUN/SUN2012/SUN2012',
bg_atyp)):
background = Image.open(
os.path.join(
'/media/noor/DataNS/Imagesets/SUN/SUN2012/SUN2012',
bg_atyp, bg_im))
background2 = background.convert("RGBA")
result = Image.alpha_composite(background2, ob)
#print(image.split("/")[-1])
if not os.path.exists(
os.path.join(
'/media/noor/DataNS/Imagesets/DNimal_I_background/humanstim/',
image.split("/")[-2],
image.split("/")[-1], 'a_background', 'loc3')):
os.makedirs(
os.path.join(
'/media/noor/DataNS/Imagesets/DNimal_I_background/humanstim/',
image.split("/")[-2],
image.split("/")[-1], 'a_background', 'loc3'))
newfilename = os.path.join(
'/media/noor/DataNS/Imagesets/DNimal_I_background/humanstim/',
def main(args):
all_model_class = []
all_model_ids = []
with open(args.task_file, 'r') as f:
lines = f.readlines()
for line in lines:
if line == '':
continue
tmp = line.rstrip('\n').split(' ')
all_model_class.append(tmp[0])
all_model_ids.append(tmp[1])
for i, curr_model_id in enumerate(all_model_ids):
start_time = time.time()
rendering_curr_model_root = os.path.join(DIR_RENDERING_PATH,
all_model_class[i],
all_model_ids[i])
rendering_curr_model_save_png_root = os.path.join(
rendering_curr_model_root, 'rendering_png')
if not os.path.exists(rendering_curr_model_save_png_root):
os.mkdir(rendering_curr_model_save_png_root)
if os.path.exists(
os.path.join(rendering_curr_model_save_png_root,
'%.2d_rgb.png' % (N_VIEWS - 1))):
continue
rf = open(
os.path.join(rendering_curr_model_root, 'rendering_metadata.txt'),
'r')
f = open(
os.path.join(rendering_curr_model_save_png_root,
'depth_range.txt'), 'w')
for view_id in range(N_VIEWS):
image_path = os.path.join(rendering_curr_model_root,
'rendering_exr', '%.2d.exr' % view_id)
try:
x, y, img, depth, depth_min, depth_max = convert_OpenEXR_to_sRGB(
image_path)
except:
continue
finally:
pass
img = (img * 255.0).astype(numpy.uint8)
img = Image.fromarray(img)
img.save(
os.path.join(rendering_curr_model_save_png_root,
'%.2d_rgba.png' % view_id))
depth = (depth * 255.).astype(numpy.uint8)
depth = Image.fromarray(depth)
depth = depth.convert('L')
# save depth map & range
depth.save(
os.path.join(rendering_curr_model_save_png_root,
'%.2d_depth.png' % view_id))
depth_unit = RENDERING_MAX_CAMERA_DIST * float(
rf.readline().split(' ')[3])
print(depth_min, depth_max, depth_unit, file=f)
# convert to jpg, save jpg
background = Image.new('RGBA', (x, y), (255, 255, 255, 255))
img_rgb = Image.alpha_composite(background, img)
img_rgb.convert('RGB').save(
os.path.join(rendering_curr_model_save_png_root,
'%.2d_rgb.png' % view_id))
#print('depth min:', depth_min, ',max:', depth_max)
f.close()
rf.close()
end_time = time.time()
print('transfer model in', end_time - start_time, ' secs')
d.text((1100, 460), PAQ, font=fnt50, fill=(0, 0, 0, 180))
linea1 = "________________________________"
linea11 = "_____________________________"
linea2 = "_________________________________________________________"
###LINEAS
d.text((300, 80), linea2, font=fnt50, fill=(0, 0, 0, 220))
d.text((1100, 155), linea1, font=fnt50, fill=(0, 0, 0, 220))
d.text((1100, 225), linea1, font=fnt50, fill=(0, 0, 0, 220))
d.text((1100, 400), linea1, font=fnt50, fill=(0, 0, 0, 220))
d.text((1100, 400), linea1, font=fnt50, fill=(0, 0, 0, 220))
d.text((150, 560), linea11, font=fnt50, fill=(0, 0, 0, 220))
d.text((270, 560), linea11, font=fnt50, fill=(0, 0, 0, 220))
out = Image.alpha_composite(base, txt)
out.save('nommm.png')
img = Image.open('nommm.png')
# open an image file (.bmp,.png,.png,.gif) you have in the working folder
nuevoAncho = 2980
nuevoAlto = 4200
nImg = img.resize((nuevoAncho, nuevoAlto))
# Guarda la imagen
nImg.save('nommmsss.png')
def mouth_display_png(image_absolute_path, threshold=70,
invert=False, x=0, y=0):
"""Converts a png image into the appropriate encoding for the
Arduino Mark I enclosure.
NOTE: extract this out of api.py when re structuing the
enclosure folder
Args:
image_absolute_path (string): The absolute path of the image
threshold (int): The value ranges from 0 to 255. The pixel will
draw on the faceplate it the value is below a
threshold
invert (bool): inverts the image being drawn.
x (int): x offset for image
y (int): y offset for image
"""
# to understand how this funtion works you need to understand how the
# Mark I arduino proprietary encoding works to display to the faceplate
img = Image.open(image_absolute_path).convert("RGBA")
img2 = Image.new('RGBA', img.size, (255, 255, 255))
width = img.size[0]
height = img.size[1]
# strips out alpha value and blends it with the RGB values
img = Image.alpha_composite(img2, img)
img = img.convert("L")
# crop image to only allow a max width of 16
if width > 32:
img = img.crop((0, 0, 32, height))
width = img.size[0]
height = img.size[1]
# crop the image to limit the max height of 8
if height > 8:
img = img.crop((0, 0, width, 8))
width = img.size[0]
height = img.size[1]
encode = ""
# Each char value represents a width number starting with B=1
# then increment 1 for the next. ie C=2
width_codes = ['B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a']
height_codes = ['B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
encode += width_codes[width - 1]
encode += height_codes[height - 1]
# Turn the image pixels into binary values 1's and 0's
# the Mark I face plate encoding uses binary values to
# binary_values returns a list of 1's and 0s'. ie ['1', '1', '0', ...]
binary_values = []
for i in range(width):
for j in range(height):
if img.getpixel((i, j)) < threshold:
if invert is False:
binary_values.append('1')
else:
binary_values.append('0')
else:
if invert is False:
binary_values.append('0')
else:
binary_values.append('1')
# these values are used to determine how binary values
# needs to be grouped together
number_of_top_pixel = 0
number_of_bottom_pixel = 0
if height > 4:
number_of_top_pixel = 4
number_of_bottom_pixel = height - 4
else:
number_of_top_pixel = height
# this loop will group together the individual binary values
# ie. binary_list = ['1111', '001', '0101', '100']
binary_list = []
binary_code = ''
increment = 0
alternate = False
for val in binary_values:
binary_code += val
increment += 1
if increment == number_of_top_pixel and alternate is False:
# binary code is reversed for encoding
binary_list.append(binary_code[::-1])
increment = 0
binary_code = ''
alternate = True
elif increment == number_of_bottom_pixel and alternate is True:
binary_list.append(binary_code[::-1])
increment = 0
binary_code = ''
alternate = False
# Code to let the Makrk I arduino know where to place the
# pixels on the faceplate
pixel_codes = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P']
for binary_values in binary_list:
number = int(binary_values, 2)
pixel_code = pixel_codes[number]
encode += pixel_code
return encode