def opaque_rectangle(self,
x,
y,
width,
height,
fill="#000000",
opacity=128,
pattern=False):
LOGGER.debug("Draw opaque rectangle (%s, %s) - (%s, %s)" %
(x, y, width, height))
color_layer = Image.new("RGBA", self.image.size, fill)
alpha_mask = Image.new("L", self.image.size, 0)
alpha_mask_draw = ImageDraw.Draw(alpha_mask)
alpha_mask_draw.rectangle((x, y, x + width, y + height),
opacity) # Opacity here?
self._init_image(Image.composite(color_layer, self.image, alpha_mask))
if pattern:
pat_mask = Image.new("L", (width, height), 0)
pat_mask_draw = ImageDraw.Draw(pat_mask)
pattern_size = 8
offset = 14
line_offset = -pattern_size
while line_offset < width:
pat_mask_draw.line((line_offset + 20, -pattern_size,
line_offset, height + pattern_size), 40,
pattern_size)
line_offset += pattern_size + offset
final_mask = Image.new("L", self.image.size, 0)
final_mask.paste(pat_mask, (x, y, x + width, y + height))
white = Image.new("RGBA", self.image.size, "#FFFFFF")
self._init_image(Image.composite(white, self.image, final_mask))
def render_hex_body(terr_file, border_left_file, border_right_file):
terr_code=terr_file.split('.')[0]
left_code=border_left_file.split('.')[0]
right_code=border_right_file.split('.')[0]
file_name="middle_T."+terr_name+".B1."+left_code+".B2."+right_code+".png"
if (not os.path.isfile(file_name)):
terr=Image.open(get_terrain_piece(terr_file,"M"))
left=Image.open(get_border(border_left_file,'L'))
right=Image.open(get_border(border_right_file,'R'))
largest=None
images=[terr,left,right]
for i in images:
if i.size > largest:
largest=i.size
if (terr.size<largest):
terr=terr.resize(largest,Image.BICUBIC)
if (left.size<largest):
left=left.resize(largest,Image.BICUBIC)
if (right.size<largest):
right=right.resize(largest,Image.BICUBIC)
terr=Image.composite(left,terr,left)
terr=Image.composite(right,terr,right)
terr.save(file_name)
return file_name
def generateActivatedItemIcons():
icons = [ f for f in listdir("icons_activated/") if isfile(join("icons_activated/",f)) and f.split(".")[-1] == "png" ]
for i in icons:
filename = ".".join(i.split(".")[0:-1])
im = Image.open("icons_activated/"+i).convert("RGBA")
color_layer = Image.new('RGBA', im.size, (0, 0, 0))
line_layer = Image.new('RGBA', im.size, (109, 109, 109))
alpha_mask = Image.new('L', im.size, 0)
alpha_mask_draw = ImageDraw.Draw(alpha_mask)
alpha_mask_draw.line([(im.size[0]//2, im.size[1]//2), (im.size[0]//2, 0)], fill=186, width = 3)
newim = Image.blend(im, color_layer, 0.51)
newim = Image.composite(line_layer, newim, alpha_mask)
newim.save("icons_activated/"+filename+"-activated.png")
newim = Image.blend(im, color_layer, 0.29)
newim = Image.composite(line_layer, newim, alpha_mask)
newim.save("icons_activated/"+filename+"-activated-done.png")
rect_layer = Image.new('RGBA', im.size, (0, 0, 0))
rect_alpha_mask = Image.new("L", im.size, 0)
rect_alpha_mask_draw = ImageDraw.Draw(rect_alpha_mask)
rect_alpha_mask_draw.rectangle((0, 0, im.size[0]//2, im.size[1]), fill=131)
rect_alpha_mask_draw.rectangle((im.size[0]//2+1, 0, im.size[0], im.size[1]), fill=75)
newim = Image.composite(rect_layer, im, rect_alpha_mask)
newim = Image.composite(line_layer, newim, alpha_mask)
newim.save("icons_activated/"+filename+"-activated-half.png")
def text_watermark(source_file,
out_base_path='.',
text='@Grayson',
angle=23,
opacity=0.50):
'''''
添加一个文字水印，做成透明水印的模样，应该是png图层合并
http://www.pythoncentral.io/watermark-images-python-2x/
这里会产生著名的 ImportError("The _imagingft C module is not installed") 错误
Pillow通过安装来解决 pip install Pillow
'''
img = Image.open(source_file)
# watermark = Image.new('RGBA', img.size, (255, 255, 255)) # 我这里有一层白色的膜，去掉(255,255,255) 这个参数就好了
watermark = Image.new('RGBA',
img.size) # 我这里有一层白色的膜，去掉(255,255,255) 这个参数就好了
# FONT = abspath + "/fonts/NewYork.ttf"
FONT = "../../fonts/NewYork.ttf"
size = 1
n_font = ImageFont.truetype(FONT, size) # 得到字体
n_width, n_height = n_font.getsize(text)
text_box = min(watermark.size[0], watermark.size[1]) / 4
print(text_box)
# text_box = 300
while (n_width + n_height < text_box):
size += 2
n_font = ImageFont.truetype(FONT, size=size)
n_width, n_height = n_font.getsize(text) # 文字逐渐放大，但是要小于图片的宽高最小值
# text_width = (watermark.size[0] - n_width) / 2
text_width = (watermark.size[0] - n_width)
# text_height = (watermark.size[1] - n_height) / 2
text_height = (watermark.size[1] - n_height)
# watermark = watermark.resize((text_width,text_height), Image.ANTIALIAS)
print(text_width, text_height)
draw = ImageDraw.Draw(watermark, 'RGBA') # 在水印层加画笔
delta_right = -text_width / 9 # 字体与右侧的距离
delta_bottom = -text_height / 24 # 字体与底部的距离
draw.text((delta_right + text_width, delta_bottom + text_height),
text,
font=n_font,
fill="#ffffff")
# watermark = watermark.rotate(angle, Image.BICUBIC)
alpha = watermark.split()[3]
alpha = ImageEnhance.Brightness(alpha).enhance(opacity)
watermark.putalpha(alpha)
str_uuid = ''.join(str(uuid.uuid4()).split('-'))
splits = source_file.split('.')
image_suffix = splits[len(splits) - 1]
out_file = out_base_path + '/' + str_uuid + '.' + image_suffix
print(out_file)
Image.composite(watermark, img, watermark).save(out_file, image_suffix)
print(u"文字水印成功")
return str_uuid
def watermark(self, image):
""" Apply a watermark to an image """
mark = Image.open(watermark_img)
im = Image.open(image)
if im.mode != 'RGBA':
im = im.convert('RGBA')
layer = Image.new('RGBA', im.size, (0,0,0,0))
position = (im.size[0] - mark.size[0], im.size[1] - mark.size[1])
layer.paste(mark, position)
outfile = join(out, basename(image))
Image.composite(layer, im, layer).save(outfile)
return outfile
def watermark(self, image):
""" Apply a watermark to an image """
mark = Image.open(watermark_img)
im = Image.open(image)
if im.mode != 'RGBA':
im = im.convert('RGBA')
layer = Image.new('RGBA', im.size, (0, 0, 0, 0))
position = (im.size[0] - mark.size[0], im.size[1] - mark.size[1])
layer.paste(mark, position)
outfile = join(out, basename(image))
Image.composite(layer, im, layer).save(outfile)
return outfile
def batch(infolder, outfolder, watermark):
mark = Image.open(watermark)
for root, dirs, files in os.walk(infolder):
for name in files: try:
im = Image.open(join(root, name))
if im.mode != 'RGBA':
im = im.convert('RGBA')
layer = Image.new('RGBA', im.size, (0,0,0,0))
position = (im.size[0]-mark.size[0], im.size[1]-mark.size[1])
layer.paste(mark, position)
Image.composite(layer, im, layer).save( join(outfolder, name))
except Exception, (msg):
print msg
def clearRed(img):
source = img.split()
red_mask = source[0].point(lambda i: i > 130 and 255)
blue_mask = source[2].point(lambda i:i < 50 and 80)
green_mask = source[1].point(lambda i: i < 50 and 80)
imgR = Image.composite(source[0], img, red_mask)
imgB = Image.composite(source[2], imgR, blue_mask)
imgG = Image.composite(source[1], imgB, green_mask)
return imgG
def render_hex_corner(top_terr_file, bottom_terr_file, is_forward_slash, border_file):
top_code=top_terr_file.split('.')[0]
bottom_code=bottom_terr_file.split('.')[0]
border_code=border_file.split('.')[0]
if is_forward_slash:
corner_type = "F"
upper_type = "UL"
lower_type = "LR"
else:
corner_type = "B"
upper_type = "UR"
lower_type = "LL"
file_name="corner_T1."+top_code+'.T2.'+bottom_code+'.B.'+border_code+'_'+corner_type+'.png'
if (not os.path.isfile(file_name)):
top_terr=Image.open(get_terrain_piece(top_code,upper_type))
if top_terr.mode!='RGBA':
top_terr=top_terr.convert('RGBA')
bottom_terr=Image.open(get_terrain_piece(bottom_code,lower_type))
if bottom_terr.mode!='RGBA':
bottom_terr=bottom_terr.convert('RGBA')
if (top_terr.size!=bottom_terr.size):
if (top_terr.size[0]*top_terr.size[1] > bottom_terr.size[0]*bottom_terr.size[1]):
bottom_terr=bottom_terr.resize(top_terr.size,Image.BICUBIC)
else:
top_terr=top_terr.resize(bottom_terr.size,Image.BICUBIC)
mask=Image.new("1", top_terr.size)
mask_draw=ImageDraw.Draw(mask)
if is_forward_slash:
mask_draw.polygon(((0,0),(0,mask.size[1]),(mask.size[0],0)), fill=1)
else:
mask_draw.polygon(((0,0),(mask.size[0],mask.size[1]),(mask.size[0],0)), fill=1)
corner=Image.composite(top_terr,bottom_terr,mask)
#border image must have transparency, 'cause I'm lazy.
border=Image.open(get_border(border_code,corner_type))
if border.mode!='RGBA':
border=border.convert('RGBA')
if (corner.size!=border.size):
if (corner.size[0]*corner.size[1] > border.size[0]*border.size[1]):
border=border.resize(corner.size,Image.BICUBIC)
else:
corner=corner.resize(border.size,Image.BICUBIC)
print "First composite done. top_terr size:"+str(top_terr.size)+" bottom_terr size:"+str(bottom_terr.size)+" mask size:"+str(mask.size)+" corner size:"+str(corner.size)+" border size:"+str(border.size)
corner=Image.composite(border,corner,border)
corner.save(file_name, palette=Image.ADAPTIVE)
print "Palettes. top:"+top_terr.mode+" bottom:"+bottom_terr.mode+" mask:"+mask.mode+" border:"+border.mode+" corner:"+corner.mode
return file_name
def captcha(self, guess):
font = self._get_captcha_font()
if self.plazma_cache['reusage'] <= -5:
self._init_cache()
self.plazma_cache['reusage'] -= 1
mask = Image.new('RGBA', (self.plazma_cache['size'][0], self.plazma_cache['size'][1]))
font_width, _ = font.getsize(guess)
font_width /= len(guess)
x_offset = random.randint(-1, 1) * 5
draw = ImageDraw.Draw(mask)
for i in guess:
x_offset += font_width + random.randint(1, 5)
y_offset = random.randint(1, 7) * 5
draw.text((x_offset + random.randint(-(font_width / 10), (font_width / 10)) * 2, y_offset), i, font=font)
angle = random.randint(-2, 3) * 5
mask = mask.rotate(angle)
pattern_1 = pattern_2 = None
while pattern_1 is pattern_2:
pattern_1 = self.plazma_cache['plazma'][random.randint(0, self.plazma_cache_size - 1)]
pattern_2 = self.plazma_cache['plazma'][random.randint(0, self.plazma_cache_size - 1)]
result = Image.composite(pattern_1, pattern_2, mask)
if self._filter is not None:
for _ in range(self._diff_mode):
result = result.filter(self._filter)
return result
def draw_func(self, fobj):
"""Draws a function on the graph image using image compositing.
The function must have a value method (Points instances work)."""
eq = getattr(fobj, "eq", "=") # Check equality
curve_img = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
cpix, fpcolor, pthick = curve_img.load(), fobj.pcolor, fobj.pthick
if not isinstance(pthick, list): # Square point
pthick = [pthick]
if "=" in eq:
for px in xrange(self.width - 1): # Iterate over all columns
yvals = fobj(round(self.coord(px)[0], self.round), self.gvars)
if yvals is None:
continue
if not isinstance(yvals, list): # For single points
yvals = [yvals]
for yval in yvals:
py = self.pixel(y=yval)[1]
for ppx, ppy in self.pad_point(px, py, *pthick):
if ((0 <= ppx < self.width) and
(0 <= ppy < self.height)):
cpix[ppx, ppy] = fpcolor
self.gimg = Image.composite(curve_img, self.gimg, curve_img)
self.gimg.save(self.fname)
if "<" in eq:
self.shade_between(fobj, self.bot_axis)
elif ">" in eq:
self.shade_between(fobj, self.top_axis)
def start():
getdir(picdir)
for tex in imglist:
if tex.endswith('.jpg') or tex.endswith('.jpeg') or tex.endswith('.png')or tex.endswith('.JPG') or tex.endswith('JPEG') or tex.endswith('PNG'):
dir=picdir
fname = dir+"\\"+tex
im2 = Image.open(fname)
tex = tex.replace('.jpg', '')
tex = tex.replace('.jpeg', '')
tex = tex.replace('.png', '')
tex = tex.replace('.JPG', '')
tex = tex.replace('.JPEG', '')
tex = tex.replace('.PNG', '')
tex = tex.split('-')
media = tex[0]
title = tex[1]
global t
if title in t:
continue
im1=imdic.get(media)
im3 = im2.resize((592, 296))
if im1==None:
b="\n"+title+" 出现了问题\n"
text.insert(Tkinter.END,b.decode('gbk'))
continue
layer = Image.new('RGBA', im1.size, (0, 0, 0, 0))
layer.paste(im3, (0, 204))
im4 = Image.composite(layer, im1, layer)
if not os.path.exists(desk+r'\带logo的图片'):
os.makedirs(desk+r'\带logo的图片')
out=desk+r'\带logo的图片'
im4.save(os.path.join(out,title+".jpg"),quality=100)
t.extend([title])
a=title+" 处理成功 "
text.insert(Tkinter.END,a.decode('gbk'))
def get_location_piece(img_set, stack,part):
#file format: location_t1.t2.tN_part.png
file_name = "location_"
is_first=True
for loc in stack:
if is_first:
is_first=False
else:
file_name+='.'
file_name+=loc
file_name+='_'+part+'.png'
Logger.log.debug('get_location_piece filename: '+file_name)
if not os.path.isfile(os.path.join(Context.terrain_dir, img_set, "split", file_name)):
terrain=Image.new("RGBA",(1,1))
for loc in stack:
terr = Image.open(os.path.join(Context.terrain_dir, get_terrain_piece(img_set, loc, part)))
if terr.mode!="RGBA":
terr=terr.convert("RGBA")
if terrain.size==(1,1):
terrain=terr
else:
if terr.size > terrain.size:
terrain.resize(terr.size,Image.BICUBIC)
elif terr.size < terrain.size:
terr.resize(terrain.size,Image.BICUBIC)
terrain=Image.composite(terr,terrain,terr)
terrain.save(os.path.join(Context.terrain_dir, img_set, "cache", file_name))
return file_name
def generate_diff(img1, img2):
_img1 = Image.open(img1)
_img2 = Image.open(img2)
#return ImageChops.blend(_img1, _img2, 0.5)
#return ImageChops.difference(_img1, _img2)
bld = Image.blend(_img1, _img2, 0.5)
return Image.composite(_img1, _img2, bld)
def add_watermark_image(im,
mark,
position_x,
position_y,
mode=None,
opacity=1):
"""Adds a watermark to an image."""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new('RGBA', im.size, (0, 0, 0, 0))
if mode == 'tile':
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif mode == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(im.size[0]) / mark.size[0],
float(im.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((im.size[0] - w) / 2, (im.size[1] - h) / 2))
else:
layer.paste(mark, (position_x, position_y))
# composite the watermark with the layer
return Image.composite(layer, im, layer)
def icons(request, project_name):
try:
get = request.GET
color = get['color'].split('/')[-1]
except:
return HttpResponseNotFound()
cache = "%s/cache/%s_icons.png" % (settings.DATA_DIR, color)
if os.path.isfile(cache):
response = HttpResponse(mimetype="image/png")
cache = open(cache, 'r')
response.write(cache.read())
cache.close()
return response
try:
im = Image.open("%s/icons_mask.png" % settings.ICONS_DIR)
except:
return HttpResponseNotFound()
bg = Image.new('RGB', im.size, color)
tr = Image.new('RGBA', im.size, (0, 0, 0, 0))
result = Image.composite(bg, tr, im)
response = HttpResponse(mimetype="image/png")
result.save(cache)
result.save(response, 'PNG')
return response
def apply_watermark(im, mark, position, opacity=1):
"""Adds a watermark to an image."""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new('RGBA', im.size, (0,0,0,0))
if position == 'tile':
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(im.size[0]) / mark.size[0], float(im.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((im.size[0] - w) / 2, (im.size[1] - h) / 2))
else:
if im.size[0] > mark.size[0] or im.size[1] > mark.size[1]:
position=tuple(map(int,position[1:-1].split(',')))
#position=((im.size[0] - mark.size[0]+position[0]) , (im.size[1] - mark.size[1] + position[1]))
position=tuple(map(lambda x,y,p:p if p>0 else x-y+p, im.size,mark.size, position))
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, im, layer)
def water_mark(img_data, opacity=1):
img = Image.open(StringIO(img_data))
mark = Image.open('/mark/path') # 水印文件可以使用指定路径
#mark = fs.get(mark_url)
if not mark:
return img_data
mark = Image.open(StringIO(mark))
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if img.mode != 'RGBA':
img = img.convert('RGBA')
img_format = 'JPEG'
else:
img_format = 'PNG'
# 指定上传图片最大宽度580和高宽600，如超过进行resize
if img.size[0] > 580:
img = img.resize((580, img.size[1]/(img.size[0]/580.0)), resample=1)
if img.size[1] > 600:
img = img.resize((img.size[0]/(img.size[1]/600.0),600), resample=1)
layer = Image.new('RGBA', img.size, (0,0,0,0))
layer.paste(mark, mark_layout(img, mark, layout))
img = Image.composite(layer, img, layer)
new_img = StringIO()
img.save(new_img, img_format, quality=100)
return new_img.getvalue()
def draw_caption(img, text, outline=2, top=False):
text_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(text_img)
w = img.size[0]
s = 100
while w >= (img.size[0] - 20):
font = ImageFont.truetype('HelveticaNeue-CondensedBlack', s)
w, h = draw.textsize(text, font=font)
s -= 1
if s <= 12: break
text_y = 0 if top else img.size[1] - h
draw.text((10, text_y), text, font=font, fill='black')
kernel = [0, 1, 2, 1, 0,
1, 2, 4, 2, 1,
2, 4, 0, 4, 1,
1, 2, 4, 2, 1,
0, 1, 2, 1, 0]
myfilter = ImageFilter.Kernel((5, 5), kernel, scale = 0.25 * sum(kernel))
for i in xrange(outline):
print 'Processing image... ' + str(int(float(i)/outline * 100)) + '%'
text_img = text_img.filter(myfilter)
print 'Processing done.'
draw = ImageDraw.Draw(text_img)
draw.text((10, text_y), text, font = font, fill = 'white')
mask_img = ImageChops.invert(text_img)
result_img = Image.composite(img, text_img, mask_img)
return result_img
def draw_image(floor, size, zones, count):
assert floor in ["top", "middle", "bottom"]
assert size in ["big", "small"]
zone_coords = data[size + "_" + floor]
for zone in zones:
assert zone in zone_coords
base_layer = Image.open("Original/%s_%s.png" % (floor, size))
color_layer = Image.new('RGBA', base_layer.size, "#ff0000")
alpha_mask = Image.new('L', base_layer.size, 0)
alpha_mask_draw = ImageDraw.Draw(alpha_mask)
for zone in zones:
coords = zone_coords[zone]
alpha_mask_draw.polygon(coords, fill=128)
base_layer = Image.composite(color_layer, base_layer, alpha_mask)
if count >= 1:
try:
for file in glob.glob("/media/ram/alarm/%s_%s_*.png" % (floor, size)):
if file != "/media/ram/alarm/%s_%s_%s.png" % (floor, size, count):
os.remove(file)
except:
pass
base_layer.save("/media/ram/alarm/%s_%s_%s.png" % (floor, size, count), "PNG")
def save(self):
import Image
import ImageDraw
im = Image.new("RGBA", (self.w * SCALE, self.h * SCALE))
draw = ImageDraw.Draw(im)
draw.rectangle(conv(0, 0, self.w, self.h), fill="white")
for src_rect in self.rects:
draw.rectangle(conv(*src_rect.xyxy()), fill="red", outline="black")
imcopy = im.copy()
ImageDraw.Draw(imcopy)
for fr in self.free_rects:
rim = Image.new("RGBA", im.size)
rimdraw = ImageDraw.Draw(rim)
rimdraw.rectangle(conv_in(*fr.xyxy()),
fill="green",
outline="black")
mask = Image.new("RGBA", im.size, "white")
maskdraw = ImageDraw.Draw(mask)
maskdraw.rectangle(conv_in(*fr.xyxy()), fill="#c01010")
mask = mask.split()[0]
imcopy = Image.composite(imcopy, rim, mask)
imcopy.save("png/%s.png" % (self.n, ))
def draw_text(self,
img,
txt,
font,
txt_color,
x_spacing=0,
offset_x=0,
offset_y=0):
draw = ImageDraw.Draw(img)
mask = font.getmask(txt)
width, height = mask.size[0] + (len(txt) - 1) * x_spacing, mask.size[1]
xstart, ystart = (img.size[0] - width) / 2 + offset_x, (
img.size[1] - height) / 2 + offset_y
for idx, c in enumerate(txt):
mask = font.getmask(c)
if mask.size[1] > 0:
mask_img = Image.new('L', mask.size)
mask_img.putdata(mask)
txt_color_img = Image.new('L', mask.size, 255)
mask_img = Image.composite(txt_color_img,
Image.new('L', mask.size, 0),
mask_img)
draw.bitmap((xstart, ystart), mask_img, txt_color)
xstart += mask.size[0] + x_spacing
def generate_watermarks(image_name, storage):
""" Generates all watermarks for the given image """
img = Image.open(storage.open(image_name))
for mark_name in settings.ALL_WATERMARK_LIST:
mark = Image.open(settings.MEDIA_ROOT+mark_name[0])
sufix = mark_name[1]
position = determine_position(POSITION, img, mark)
rotation = ROTATION
scale = 1.0
opacity = 1.0
tile = False
scale = 1.0
greyscale = False
obscure = OBSCURE
quality = QUALITY
basedir = '%s/watermarked' % os.path.dirname(image_name)
base, ext = os.path.splitext(os.path.basename(image_name))
pos = determine_position(position, img, mark)
params = {
'position': position,
'opacity': opacity,
'scale': scale,
'tile': tile,
'greyscale': greyscale,
'rotation': rotation,
'base': base,
'ext': ext,
'quality': quality,
'watermark': sufix,
'opacity_int': int(opacity * 100),
'left': pos[0],
'top': pos[1],
}
wm_name = sufix
if opacity < 1:
mark = reduce_opacity(mark, opacity)
scale = determine_scale(scale, img, mark)
mark = mark.resize(scale)
if greyscale and mark.mode != 'LA':
mark = mark.convert('LA')
layer = Image.new('RGBA', img.size, (0,0,0,0))
if tile:
first_y = position[1] % mark.size[1] - mark.size[1]
first_x = position[0] % mark.size[0] - mark.size[0]
for y in range(first_y, img.size[1], mark.size[1]):
for x in range(first_x, img.size[0], mark.size[0]):
layer.paste(mark, (x, y))
else:
layer.paste(mark, position)
# composite the watermark with the layer
composed_image = Image.composite(layer, img, layer)
memory_file = StringIO()
composed_image.save(memory_file, quality=quality, format="jpeg")
cf = ContentFile(memory_file.getvalue())
filename = "{0}.{1}".format(image_name,sufix)
storage.save(filename, cf)
def mark(self, path, position=POSITION_BOTTOM_RIGHT):
'''给单个图片打水印'''
try:
img = Image.open(path)
except IOError:
return None
if img.size[0] < self._mosaic.size[0]:
print 'width', img.size[0], self._mosaic.size[0]
return None
if img.size[1] < self._mosaic.size[1]:
print 'height', img.size[1], self._mosaic.size[1]
return None
img_area = img.size[0] * img.size[1]
mosaic_area = self._mosaic.size[0] * self._mosaic.size[1]
ratio = 4
if img_area < mosaic_area * ratio:
return None
self._locate(img, position)
layer = Image.new('RGBA', img.size, (0, 0, 0, 0))
layer.paste(self._mosaic, self.box)
return Image.composite(layer, img, layer)
def save(self):
import Image
import ImageDraw
im = Image.new("RGBA", (self.w * SCALE, self.h * SCALE))
draw = ImageDraw.Draw(im)
draw.rectangle(conv(0, 0, self.w, self.h), fill="white")
for src_rect in self.rects:
draw.rectangle(conv(*src_rect.xyxy()), fill="red", outline="black")
imcopy = im.copy()
ImageDraw.Draw(imcopy)
for fr in self.free_rects:
rim = Image.new("RGBA", im.size)
rimdraw = ImageDraw.Draw(rim)
rimdraw.rectangle(conv_in(*fr.xyxy()),
fill="green", outline="black")
mask = Image.new("RGBA", im.size, "white")
maskdraw = ImageDraw.Draw(mask)
maskdraw.rectangle(conv_in(*fr.xyxy()), fill="#c01010")
mask = mask.split()[0]
imcopy = Image.composite(imcopy, rim, mask)
imcopy.save("png/%s.png" % (self.n, ))
def draw_caption(img, text, outline=2, top=False):
text_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(text_img)
w = img.size[0]
s = 100
while w >= (img.size[0] - 20):
font = ImageFont.truetype('HelveticaNeue-CondensedBlack', s)
w, h = draw.textsize(text, font=font)
s -= 1
if s <= 12: break
text_y = 0 if top else img.size[1] - h
draw.text((10, text_y), text, font=font, fill='black')
kernel = [
0, 1, 2, 1, 0, 1, 2, 4, 2, 1, 2, 4, 0, 4, 1, 1, 2, 4, 2, 1, 0, 1, 2, 1,
0
]
myfilter = ImageFilter.Kernel((5, 5), kernel, scale=0.25 * sum(kernel))
for i in range(outline):
print('Processing image... ' + str(int(float(i) / outline * 100)) +
'%')
text_img = text_img.filter(myfilter)
print('Processing done.')
draw = ImageDraw.Draw(text_img)
draw.text((10, text_y), text, font=font, fill='white')
mask_img = ImageChops.invert(text_img)
result_img = Image.composite(img, text_img, mask_img)
return result_img
def color_bg_fg(image, bg_color, fg_color):
'''change transparent background to bg_color and change
everything non-transparent to fg_color'''
fg_layer = Image.new('RGBA', image.size, fg_color)
bg_layer = Image.new('RGBA', image.size, bg_color)
masked_image = Image.composite(fg_layer, bg_layer, image)
return masked_image
def draw_func(self, fobj):
"""Draws a function on the graph image using image compositing.
The function must have a value method (Points instances work)."""
eq = getattr(fobj, "eq", "=") # Check equality
curve_img = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
cpix, fpcolor, pthick = curve_img.load(), fobj.pcolor, fobj.pthick
if not isinstance(pthick, list): # Square point
pthick = [pthick]
if "=" in eq:
for px in xrange(self.width - 1): # Iterate over all columns
yvals = fobj(round(self.coord(px)[0], self.round), self.gvars)
if yvals is None:
continue
if not isinstance(yvals, list): # For single points
yvals = [yvals]
for yval in yvals:
py = self.pixel(y=yval)[1]
for ppx, ppy in self.pad_point(px, py, *pthick):
if ((0 <= ppx < self.width)
and (0 <= ppy < self.height)):
cpix[ppx, ppy] = fpcolor
self.gimg = Image.composite(curve_img, self.gimg, curve_img)
self.gimg.save(self.fname)
if "<" in eq:
self.shade_between(fobj, self.bot_axis)
elif ">" in eq:
self.shade_between(fobj, self.top_axis)
def watermark(image, mark, position, opacity=1):
"""Adds a watermark to an image."""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if image.mode != RGBA:
image = image.convert(RGBA)
# create a transparent layer the size of the
# image and draw the watermark in that layer.
layer = Image.new(RGBA, image.size, (0, 0, 0, 0))
if position == 'tile':
for y in range(0, image.size[1], mark.size[1]):
for x in range(0, image.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(image.size[0]) / mark.size[0],
float(image.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((image.size[0] - w) / 2,
(image.size[1] - h) / 2))
else:
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, image, layer)
def process(self, image):
yield 'Color...', image
image = ImageEnhance.Color(image).enhance(0.5)
yield 'Curves...', image
bcurv = list(curves.create_curve([(0, 0), (90, 20), (140, 80), (200, 206),
(255, 255)]))
image = curves.apply_curves(image, bcurv)
yield 'Smoth...', image
blur = image.filter(ImageFilter.BLUR)
yield 'Merge smoth...', blur
gradient = gradients.create_gradient(image, 1.2, 1.4)
mask = gradient.convert("L")
mask = ImageEnhance.Brightness(mask).enhance(2.0)
image = Image.composite(image, blur, mask)
yield 'vignette...', image
image = vignette.vignette(image)
yield 'Color...', image
cyanlayer = image.copy()
colors.fill_with_color(cyanlayer, (230, 255, 255))
image = ImageChops.multiply(image, cyanlayer)
yield 'Aspect...', image
width, height = image.size
if width > height:
dheight = int(width / 16. * 9)
margin = (height - dheight) / 2
if margin > 0:
draw = ImageDraw.Draw(image)
draw.rectangle((0, 0, width, margin), fill=0)
draw.rectangle((0, height, width, height - margin), fill=0)
del draw
#image = ImageEnhance.Sharpness(image).enhance(1.1)
#image = ImageEnhance.Brightness(image).enhance(1.2)
yield 'Done', image
def watermark(self, img):
import StringIO, Image, ImageEnhance
tileImage = Image.open(StringIO.StringIO(img))
wmark = Image.open(self.watermarkimage)
assert self.watermarkopacity >= 0 and self.watermarkopacity <= 1
if wmark.mode != 'RGBA':
wmark = wmark.convert('RGBA')
else:
wmark = wmark.copy()
alpha = wmark.split()[3]
alpha = ImageEnhance.Brightness(alpha).enhance(self.watermarkopacity)
wmark.putalpha(alpha)
if tileImage.mode != 'RGBA':
tileImage = tileImage.convert('RGBA')
watermarkedImage = Image.new('RGBA', tileImage.size, (0, 0, 0, 0))
watermarkedImage.paste(wmark, (0, 0))
watermarkedImage = Image.composite(watermarkedImage, tileImage,
watermarkedImage)
buffer = StringIO.StringIO()
if watermarkedImage.info.has_key('transparency'):
watermarkedImage.save(
buffer,
self.extension,
transparency=compositeImage.info['transparency'])
else:
watermarkedImage.save(buffer, self.extension)
buffer.seek(0)
return buffer.read()
def compare_screenshots(self,approved_path, actual_path, diff_path ):
#
dataA = open(approved_path, 'rb').read()
dataB = open(actual_path, 'rb').read()
if hashlib.md5(dataA).hexdigest() != hashlib.md5(dataB).hexdigest():
#make one size
# ToDo
imageA = Image.open(approved_path)
imageB = Image.open(actual_path)
#if sizes not match - resize smalled
if ( imageA.size != imageB.size ):
#get max image size
w_size = max( [ imageA.size[0] , imageB.size[0] ] )
h_size = max( [ imageA.size[1] , imageB.size[1] ] )
#resize images with max size
imageA = imageA.resize( [ w_size , h_size ] ,Image.ANTIALIAS )
#imageA.size = [w_size , h_size]
imageB = imageB.resize( [ w_size , h_size ] ,Image.ANTIALIAS )
#imageB.size = [w_size , h_size]
#calculate diff
diff = ImageChops.difference(imageA, imageB)
#generate pretty diff image
light = Image.new('RGB', size=imageA.size, color=0xFFFFFF)
mask = Image.new('L', size=imageA.size, color=0xFF)
draw = ImageDraw.Draw(mask)
draw.rectangle((0, 0, imageA.size[0], imageA.size[1] ), fill=0x80)
imageA = Image.composite(imageA, light, mask)
imageA.paste(diff, (0,0), mask)
imageA.convert("RGB")
imageA.save( diff_path , "PNG" )
return True
return False
def apply_watermark(im, mark, position, opacity=1):
"""Adds a watermark to an image."""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new('RGBA', im.size, (0,0,0,0))
if position == 'tile':
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(im.size[0]) / mark.size[0], float(im.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((im.size[0] - w) / 2, (im.size[1] - h) / 2))
elif position == 'bd': #en bas a droite
x = im.size[0]-mark.size[0]
y = im.size[1]-mark.size[1]
layer.paste(mark, (x, y))
else:
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, im, layer)
def captcha_image(request, key):
store = get_object_or_404(CaptchaStore, hashkey=key)
text = store.challenge
if settings.CAPTCHA_FONT_PATH.lower().strip().endswith('ttf'):
font = ImageFont.truetype(settings.CAPTCHA_FONT_PATH, settings.CAPTCHA_FONT_SIZE)
else:
font = ImageFont.load(settings.CAPTCHA_FONT_PATH)
size = font.getsize(text)
size = (size[0] * 2, int(size[1] * 1.2))
image = Image.new('RGB', size, settings.CAPTCHA_BACKGROUND_COLOR)
try:
PIL_VERSION = int(NON_DIGITS_RX.sub('', Image.VERSION))
except:
PIL_VERSION = 116
xpos = 2
charlist = []
for char in text:
if char in settings.CAPTCHA_PUNCTUATION and len(charlist) >= 1:
charlist[-1] += char
else:
charlist.append(char)
for char in charlist:
fgimage = Image.new('RGB', size, settings.CAPTCHA_FOREGROUND_COLOR)
charimage = Image.new('L', font.getsize(' %s ' % char), '#000000')
chardraw = ImageDraw.Draw(charimage)
chardraw.text((0, 0), ' %s ' % char, font=font, fill='#ffffff')
if settings.CAPTCHA_LETTER_ROTATION:
if PIL_VERSION >= 116:
charimage = charimage.rotate(random.randrange(*settings.CAPTCHA_LETTER_ROTATION), expand=0, resample=Image.BICUBIC)
else:
charimage = charimage.rotate(random.randrange(*settings.CAPTCHA_LETTER_ROTATION), resample=Image.BICUBIC)
charimage = charimage.crop(charimage.getbbox())
maskimage = Image.new('L', size)
maskimage.paste(charimage, (xpos, 4, xpos + charimage.size[0], 4 + charimage.size[1]))
size = maskimage.size
image = Image.composite(fgimage, image, maskimage)
xpos = xpos + 2 + charimage.size[0]
image = image.crop((0, 0, xpos + 1, size[1]))
draw = ImageDraw.Draw(image)
for f in settings.noise_functions():
draw = f(draw, image)
for f in settings.filter_functions():
image = f(image)
out = StringIO()
image.save(out, "GIF")
out.seek(0)
response = HttpResponse()
response['Content-Type'] = 'image/png'
response.write(out.read())
return response
def _write_tile(self,image,z,cell):
"""Writes the actual tile configuration to disk"""
try:
path = os.path.join(self.config.tilepath,str(z),str(int(cell['z'][z]['x'])))
print path
os.makedirs(os.path.join(self.config.tilepath,str(z),str(int(cell['z'][z]['x']))))
except os.error: pass
target = os.path.join(self.config.tilepath,str(z),str(int(cell['z'][z]['x'])),str('%s.%s' % (int(cell['z'][z]['y']),self.config.get('map','format'))))
try:
image.save(target,'PNG')
except IOError:
self.offline_image.save(target,'PNG')
if self.config.getboolean('service','ll_support') and z >= 11:
regions_per_tile = math.pow(2,abs(z - self.config.getint('map','raw_ztop')))
regions_from_top = int(regions_per_tile * (cell['z'][z]['x']%1))
regions_from_left = int(regions_per_tile * (cell['z'][z]['y']%1))
tile_name_x = int(cell['z'][self.config.getint('map','raw_ztop')]['x']) - regions_from_top
tile_name_y = int(cell['z'][self.config.getint('map','raw_ztop')]['y']) - regions_from_left
#print '%s,%s (%s:%s,%s)' % (tile_name_x,tile_name_y,z,regions_from_top,regions_from_left)
target = '%s/ll/map-%s-%s-%s-objects.jpg' % (self.config.tilepath,str(abs((self.config.getint('map','raw_ztop')+1) - z)),str(tile_name_x),str(tile_name_y))
if len(image.split()) == 4:
image = image.transpose(Image.FLIP_TOP_BOTTOM)
r,g,b,a = image.split()
image = Image.composite(image,self.ll_background,a)
try: image.save(target,'JPEG')
except IOError: self.offline_image.save(target,'JPEG')
def watermark(im, mark, position, opacity=1):
"""Adds a watermark to an image."""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new('RGBA', im.size, (0,0,0,0))
if position == 'tile':
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(im.size[0]) / mark.size[0], float(im.size[1]) / mark.size[1])
#w = int(mark.size[0] * ratio * .4)
#h = int(mark.size[1] * ratio * .4)
w,h = 266,126
#raise Exception(str(w)+' '+str(h))
mark = mark.resize((w, h), Image.ANTIALIAS)
layer.paste(mark, ((im.size[0] - w), (im.size[1] - h)))
else:
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, im, layer)
def get_location_piece(stack,part):
#file format: location_t1.t2.tN_part.png
file_name="location_"
is_first=True
for loc in stack:
if loc.terrain is not None:
if not is_first:
is_first=false
else:
file_name+='.'
file_name+=loc.terrain.split('.')[0]
file_name+='_'+part+'.png'
if not os.path.isfile(file_name):
terrain=Image.new((1,1),"RGBA")
for loc in stack:
terr=Image.open(get_terrain_piece(loc.terrain,part))
if terr.mode!="RGBA":
terr=terr.convert("RGBA")
if terrain.size==(1,1):
terrain=terr
else:
if terr.size > terrain.size:
terrain.resize(terr.size,Image.BICUBIC)
elif terr.size < terrain.size:
terr.resize(terrain.size,Image.BICUBIC)
terrain=Image.composite(terr,terrain,terr)
return file_name
def green_key(canvas, key_image, img_source, mtype=KEY_REG):
s3 = key_image.split()
mask = (s3[1].point(lambda i: (i > 254 or 256))
) # cut out green area (overlay)
if (mtype == KEY_BLUR or mtype == KEY_BLUR_BRIGHT
or mtype == KEY_BLUR_BRIGHT_MORE):
mask = mask.filter(ImageFilter.SMOOTH_MORE)
mask = mask.filter(ImageFilter.BLUR)
mask = mask.filter(ImageFilter.SMOOTH_MORE)
if (mtype == KEY_BLUR_BRIGHT):
mask = (mask.point(lambda k: (k * 2)))
elif (mtype == KEY_BLUR_BRIGHT_MORE):
mask = (mask.point(lambda k: k > 20 and (k * k)))
# mask.show()
# mask.save("images/saved/mask.jpg")
# canvas.convert("RGBA") # needed?
if (canvas.size != img_source.size): # fix image size
if (canvas.size < img_source.size):
print "resizing canvas", canvas.size, img_source.size, key_image.size
canvas = ImageOps.fit(canvas, img_source.size)
else:
print "resizing img_source and mask", canvas.size, img_source.size, key_image.size
img_source = ImageOps.fit(img_source, canvas.size)
mask = ImageOps.fit(mask, canvas.size)
image = Image.composite(img_source, canvas, mask)
return image
def meme_stamp(image_path, toptext, bottomtext, color="white"):
font=ImageFont.truetype("Impact.ttf", 26)
im = Image.open(os.getcwd() + image_path)
# Gotta capitalize dat text!
toptext = toptext.upper()
bottomtext = bottomtext.upper()
# Dat picture margin
margin=(5,5)
if im.mode != "RGBA":
im = im.convert("RGBA")
# Make a layer. yep. awesome comment.
textlayer = Image.new("RGBA", im.size, (0,0,0,0))
textdraw = ImageDraw.Draw(textlayer)
# Find centered locations for top and bottom text
toptextsize = textdraw.textsize(toptext, font=font)
bottomtextsize = textdraw.textsize(bottomtext, font=font)
toppos = top_text_pos(im.size,toptextsize,margin)
bottompos = bottom_text_pos(im.size,bottomtextsize,margin)
# Draw dat text
textdraw.text(toppos, toptext, font=font, fill=color)
textdraw.text(bottompos, bottomtext, font=font, fill=color)
# Return dat image
return Image.composite(textlayer, im, textlayer)
def DrawFrame(self):
mask = Image.new("L", (self.x_size, self.y_size), self.mask_background)
frame_output = Image.new("RGB", (self.x_size, self.y_size),
self.background_color)
mask_draw = ImageDraw.Draw(mask)
slope = float(self.y_thick) / self.x_thick
for x in range(self.x_thick):
# Auto Bevel using (x, x)
linecolor = self.ColorFunc(x, self.x_thick)
clist = [(x, x * slope), (x, self.y_size - x * slope)]
mask_draw.line(clist, fill=linecolor)
clist = [(self.x_size - x, x * slope),
(self.x_size - x, self.y_size - x * slope)]
mask_draw.line(clist, fill=linecolor)
for y in range(self.y_thick):
linecolor = self.ColorFunc(y, self.y_thick)
clist = [(y / slope, y), (self.x_size - y / slope, y)]
mask_draw.line(clist, fill=linecolor)
clist = [(y / slope, self.y_size - y),
(self.x_size - y / slope, self.y_size - y)]
mask_draw.line(clist, fill=linecolor)
# FIXME(Sean): repeat instead of crop
#mask_input_im = self.back_im.crop((0, 0, self.x_size, self.y_size))
mask_input_im = Image.new("RGB", (self.x_size, self.y_size),
self.background_color)
mask_input_im.paste(self.back_im.resize((self.x_size, self.y_size)),
(0, 0))
im_out = Image.composite(mask_input_im, frame_output, mask)
#return mask
return im_out
def draw_marker(width, height, offset, filename):
im = Image.new('L', (128, 256), 255)
draw = ImageDraw.Draw(im)
cx = (im.size[0] / 2) + 1.5
cy = (im.size[1] / 4) + 1.5
radius = width * 4.0 / 2.0
offset = int(offset * 4.0)
for thickness, colour in ((0, 0x60), (4, 0xE0)):
ol = im.copy()
r = radius + 0.5 - thickness
draw.ellipse((cx - r, cy - r, cx + r, cy + r), fill=colour)
x1 = offset + 0.5 - (thickness * 1.5)
y1 = (height * 4.0) + 0.5 - (width * 2.0) - (thickness * 2.0)
draw.polygon((cx + 0.5, cy + y1, cx - 0.5, cy + y1,
cx - x1, cy + 16.5, cx + x1, cy + 16.5),
fill=colour)
del draw
im = im.resize((im.size[0] / 4, im.size[1] / 4), Image.ANTIALIAS)
ol = ol.resize(im.size, Image.ANTIALIAS)
mask = Image.eval(ol, lambda x: (0, 255)[x < 210])
im = Image.composite(im, ImageChops.constant(im, 0), mask)
im = im.crop(im.getbbox())
im.save(filename, transparency=0)
def watermark(im, mark, position, opacity=1):
"""添加水印"""
try:
if opacity < 1:
mark = set_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
if im.size[0] < mark.size[0] or im.size[1] < mark.size[1]:
print "The mark image size is larger size than original image file."
return False
#设置水印位置
if position == 'left_top':
x = 0
y = 0
elif position == 'left_bottom':
x = 0
y = im.size[1] - mark.size[1]
elif position == 'right_top':
x = im.sizep[0] - mark.size[0]
elif position == 'right_bottom':
x = im.size[0] - mark.size[0]
y = im.size[1] - mark.size[1]
else:
x = (im.size[0] - mark.size[0]) / 2
y = (im.size[1] - mark.size[1]) / 2
layer = Image.new('RGBA', im.size)
layer.paste(mark,(x,y))
return Image.composite(layer, im, layer)
except Exception as e:
print ">>>>>> WaterMark EXCEPTION: " + str(e)
return False
def add_watermark_text(im,
text,
angle=23,
opacity=0.25,
font='/Library/Fonts/Copperplate.ttc'):
if im.mode != 'RGBA':
im = im.convert('RGBA')
watermark = Image.new('RGBA', im.size, (0, 0, 0, 0))
size = 2
n_font = ImageFont.truetype(font, size)
n_width, n_height = n_font.getsize(text)
# grow size until the limit is reached
while n_width + n_height < watermark.size[0]:
size += 2
n_font = ImageFont.truetype(font, size)
n_width, n_height = n_font.getsize(text)
draw = ImageDraw.Draw(watermark, 'RGBA')
draw.text(((watermark.size[0] - n_width) / 2,
(watermark.size[1] - n_height) / 2),
text, (0, 0, 0),
font=n_font)
watermark = watermark.rotate(angle, Image.BICUBIC)
alpha = watermark.split()[3]
alpha = ImageEnhance.Brightness(alpha).enhance(opacity)
watermark.putalpha(alpha)
return Image.composite(watermark, im, watermark)
def generate_image(text, font_file, size, colour, image_destination):
"""
Text transform based on:
http://nedbatchelder.com/blog/200801/truly_transparent_text_with_pil.html
http://phark.typepad.com/phark/2003/08/accessible_imag.html
"""
pos = (0,0)
image = Image.new("RGB", (1, 1), (0,0,0))
font = ImageFont.truetype(font_file, size)
image = image.resize(font.getsize(text))
alpha = Image.new("L", image.size, "black")
# Make a grayscale image of the font, white on black.
imtext = Image.new("L", image.size, 0)
drtext = ImageDraw.Draw(imtext)
drtext.text(pos, text, font=font, fill="white")
# Add the white text to our collected alpha channel. Gray pixels around
# the edge of the text will eventually become partially transparent
# pixels in the alpha channel.
alpha = ImageChops.lighter(alpha, imtext)
# Make a solid colour, and add it to the colour layer on every pixel
# that has even a little bit of alpha showing.
solidcolour = Image.new("RGBA", image.size, colour)
immask = Image.eval(imtext, lambda p: 255 * (int(p != 0)))
image = Image.composite(solidcolour, image, immask)
# These two save()s are just to get demo images of the process.
#image.save("transcolour.png", "PNG")
#alpha.save("transalpha.png", "PNG")
# Add the alpha channel to the image, and save it out.
image.putalpha(alpha)
image.save(image_destination, 'PNG')
return image
def green_key(canvas,key_image,img_source,mtype=KEY_REG):
s3 = key_image.split()
mask = (s3[1].point(lambda i: (i > 254 or 256))) # cut out green area (overlay)
if(mtype == KEY_BLUR or mtype == KEY_BLUR_BRIGHT or mtype == KEY_BLUR_BRIGHT_MORE):
mask = mask.filter(ImageFilter.SMOOTH_MORE)
mask = mask.filter(ImageFilter.BLUR)
mask = mask.filter(ImageFilter.SMOOTH_MORE)
if(mtype == KEY_BLUR_BRIGHT):
mask = (mask.point(lambda k: (k*2)))
elif(mtype == KEY_BLUR_BRIGHT_MORE):
mask = (mask.point(lambda k: k > 20 and (k*k)))
# mask.show()
# mask.save("images/saved/mask.jpg")
# canvas.convert("RGBA") # needed?
if(canvas.size != img_source.size): # fix image size
if(canvas.size < img_source.size):
print "resizing canvas", canvas.size, img_source.size, key_image.size
canvas = ImageOps.fit(canvas,img_source.size)
else:
print "resizing img_source and mask", canvas.size, img_source.size, key_image.size
img_source = ImageOps.fit(img_source,canvas.size)
mask = ImageOps.fit(mask,canvas.size)
image = Image.composite(img_source,canvas,mask)
return image
def draw_marker(width, height, offset, filename):
im = Image.new('L', (128, 256), 255)
draw = ImageDraw.Draw(im)
cx = (im.size[0] / 2) + 1.5
cy = (im.size[1] / 4) + 1.5
radius = width * 4.0 / 2.0
offset = int(offset * 4.0)
for thickness, colour in ((0, 0x60), (4, 0xE0)):
ol = im.copy()
r = radius + 0.5 - thickness
draw.ellipse((cx - r, cy - r, cx + r, cy + r), fill=colour)
x1 = offset + 0.5 - (thickness * 1.5)
y1 = (height * 4.0) + 0.5 - (width * 2.0) - (thickness * 2.0)
draw.polygon((cx + 0.5, cy + y1, cx - 0.5, cy + y1, cx - x1, cy + 16.5,
cx + x1, cy + 16.5),
fill=colour)
del draw
im = im.resize((im.size[0] / 4, im.size[1] / 4), Image.ANTIALIAS)
ol = ol.resize(im.size, Image.ANTIALIAS)
mask = Image.eval(ol, lambda x: (0, 255)[x < 210])
im = Image.composite(im, ImageChops.constant(im, 0), mask)
im = im.crop(im.getbbox())
im.save(filename, transparency=0)
def icons(request,project_name):
try:
get = request.GET
color = get['color'].split('/')[-1]
except:
return HttpResponseNotFound()
cache = "%s/cache/%s_icons.png" % (settings.DATA_DIR,color)
if os.path.isfile(cache):
response = HttpResponse(mimetype="image/png")
cache = open(cache,'r')
response.write(cache.read())
cache.close()
return response
try:
im = Image.open("%s/icons_mask.png" % settings.ICONS_DIR)
except:
return HttpResponseNotFound()
bg = Image.new('RGB',im.size,color)
tr = Image.new('RGBA',im.size,(0,0,0,0))
result = Image.composite(bg,tr,im)
response = HttpResponse(mimetype="image/png")
result.save(cache)
result.save(response,'PNG')
return response
def water_mark(img_data, opacity=1):
img = Image.open(StringIO(img_data))
mark = Image.open('/mark/path') # 水印文件可以使用指定路径
#mark = fs.get(mark_url)
if not mark:
return img_data
mark = Image.open(StringIO(mark))
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if img.mode != 'RGBA':
img = img.convert('RGBA')
img_format = 'JPEG'
else:
img_format = 'PNG'
# 指定上传图片最大宽度580和高宽600，如超过进行resize
if img.size[0] > 580:
img = img.resize((580, img.size[1] / (img.size[0] / 580.0)),
resample=1)
if img.size[1] > 600:
img = img.resize((img.size[0] / (img.size[1] / 600.0), 600),
resample=1)
layer = Image.new('RGBA', img.size, (0, 0, 0, 0))
layer.paste(mark, mark_layout(img, mark, layout))
img = Image.composite(layer, img, layer)
new_img = StringIO()
img.save(new_img, img_format, quality=100)
return new_img.getvalue()
def watermark(im, mark, position, opacity=1):
"""Adds a watermark to an image.
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/362879
"""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != "RGBA":
im = im.convert("RGBA")
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new("RGBA", im.size, (0, 0, 0, 0))
if position == "tile":
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == "scale":
# scale, but preserve the aspect ratio
ratio = min(float(im.size[0]) / mark.size[0], float(im.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((im.size[0] - w) / 2, (im.size[1] - h) / 2))
else:
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, im, layer)
def addWaterMark(self):
"""
Process the water mark using the main image and the
water mark image.
"""
# There are more than one way to achieve
# creating a watermark. The following flag,
# if True will use Image.composite to create
# the watermark.
using_composite = False
if self.waterMark is None:
return
# Add Transparency
self.waterMark = self.addTransparency(self.waterMark)
# Get the anchor point
pos_x, pos_y = self._getMarkPosition(self.mainImage, self.waterMark)
# Create the watermark
if not using_composite:
# Paste the image using the transparent
# watermark image as the mask.
self.mainImage.paste(self.waterMark, (pos_x, pos_y),
self.waterMark)
else:
# Alternate method to create water mark.
# using Image.composite.
# Create a new canvas
canvas = Image.new('RGBA', self.mainImage.size, (0, 0, 0, 0))
# Paste the watermark on the canvas
canvas.paste(self.waterMark, (pos_x, pos_y))
# Create a composite image
self.mainImage = Image.composite(canvas, self.mainImage, canvas)
def __call__(self, file_name):
file_path = download_image_to_cache(file_name, self.cache)
im = Image.open(file_path)
if im.mode != self.mode:
im = im.convert(self.mode)
if np.all(im.size != self.resize_to):
new_shape = (int(self.resize_to[0]), int(self.resize_to[1]))
im = im.resize(new_shape, Image.ANTIALIAS)
if self.mask is not None:
mask = self.mask
tmask = ImageOps.invert(mask.convert('RGBA').split()[-1])
im = Image.composite(im, mask, tmask).convert(self.mode)
if self._crop != (0, 0,) + self.resize_to:
im = im.crop(self._crop)
l, t, r, b = self._crop
assert im.size == (r - l, b - t)
imval = np.asarray(im, self.dtype)
rval = imval
if self.normalize:
rval -= rval.mean()
rval /= max(rval.std(), 1e-3)
else:
rval /= 255.0
assert rval.shape[:2] == self.resize_to
return rval
def apply_watermark(image, mark):
opacity = 1
position = 'bottom-right'
# reduces the opacity according the setting
if opacity < 1:
mark = reduce_opacity(mark, opacity)
# convert the image to RGBA
if image.mode != 'RGBA':
image = image.convert('RGBA')
# create a transparent layer the size of the image
layer = Image.new('RGBA', image.size, (0,0,0,0))
if position == 'center':
# define the horizontal and vertical center of the image
left = (image.size[0] / 2) - int(mark.size[0] / 2)
top = (image.size[1] / 2) - int(mark.size[1] / 2)
elif position == 'bottom-right':
padding_right = 30
padding_bottom = 20
left = (image.size[0] - int(mark.size[0])) - padding_right
top = (image.size[1] - int(mark.size[1])) - padding_bottom
# paste the watermark to the center of empty
layer.paste(mark, (left, top))
# compose the empty layer with the original image
return Image.composite(layer, image, layer)
def captcha_image(request, key):
store = get_object_or_404(CaptchaStore, hashkey=key)
text = store.challenge
if settings.CAPTCHA_FONT_PATH.lower().strip().endswith('ttf'):
font = ImageFont.truetype(settings.CAPTCHA_FONT_PATH, settings.CAPTCHA_FONT_SIZE)
else:
font = ImageFont.load(settings.CAPTCHA_FONT_PATH)
size = font.getsize(text)
size = (size[0] * 2, int(size[1] * 1.2))
image = Image.new('RGB', size, settings.CAPTCHA_BACKGROUND_COLOR)
try:
PIL_VERSION = int(NON_DIGITS_RX.sub('', Image.VERSION))
except:
PIL_VERSION = 116
xpos = 2
charlist = []
for char in text:
if char in settings.CAPTCHA_PUNCTUATION and len(charlist) >= 1:
charlist[-1] += char
else:
charlist.append(char)
for char in charlist:
fgimage = Image.new('RGB', size, settings.CAPTCHA_FOREGROUND_COLOR)
charimage = Image.new('L', font.getsize(' %s ' % char), '#000000')
chardraw = ImageDraw.Draw(charimage)
chardraw.text((0, 0), ' %s ' % char, font=font, fill='#ffffff')
if settings.CAPTCHA_LETTER_ROTATION:
if PIL_VERSION >= 116:
charimage = charimage.rotate(random.randrange(*settings.CAPTCHA_LETTER_ROTATION), expand=0, resample=Image.BICUBIC)
else:
charimage = charimage.rotate(random.randrange(*settings.CAPTCHA_LETTER_ROTATION), resample=Image.BICUBIC)
charimage = charimage.crop(charimage.getbbox())
maskimage = Image.new('L', size)
maskimage.paste(charimage, (xpos, 4, xpos + charimage.size[0], 4 + charimage.size[1]))
size = maskimage.size
image = Image.composite(fgimage, image, maskimage)
xpos = xpos + 2 + charimage.size[0]
image = image.crop((0, 0, xpos + 1, size[1]))
draw = ImageDraw.Draw(image)
for f in settings.noise_functions():
draw = f(draw, image)
for f in settings.filter_functions():
image = f(image)
out = StringIO()
image.save(out, "PNG")
out.seek(0)
response = HttpResponse()
response['Content-Type'] = 'image/png'
response.write(out.read())
return response
def apply_watermark(im, mark, position, opacity=1):
"""Adds a watermark to an image."""
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new('RGBA', im.size, (0, 0, 0, 0))
if position == 'tile':
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(im.size[0]) / mark.size[0],
float(im.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((im.size[0] - w) / 2, (im.size[1] - h) / 2))
else:
if im.size[0] > mark.size[0] or im.size[1] > mark.size[1]:
position = tuple(map(int, position[1:-1].split(',')))
#position=((im.size[0] - mark.size[0]+position[0]) , (im.size[1] - mark.size[1] + position[1]))
position = tuple(
map(lambda x, y, p: p
if p > 0 else x - y + p, im.size, mark.size, position))
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, im, layer)
def merge_image_layers(im, image_layers):
if not image_layers:
image_layers = dict()
width, height = im.size
for layer_name in LAYER_TYPES.split():
layer = image_layers[layer_name]
if type(layer) == list:
if len(layer) == width * height:
#It's a list of pixels, imagify and compose together
foreground = Image.new('RGBA', (width, height), (0, 0, 0, 0))
foreground.putdata(layer)
im = Image.composite(foreground, im, foreground)
else:
im = Image.composite(layer, im, layer)
return im
def do_composite(self):
"""usage: composite <image:pic1> <image:pic2> <image:mask>
Replace two images and a mask with their composite.
"""
image1 = self.do_pop()
image2 = self.do_pop()
mask = self.do_pop()
self.push(Image.composite(image1, image2, mask))
def watermark(im, original_witdh, position=POSITION[3], opacity=0.8):
"""Adds a watermark to an image."""
#im = Image.open(imagefile)
#水印图片宽高
#original_witdh, original_height= Image.open(im).size
#
mark_prefix = 'static/water_mark/'+water_img_check(original_witdh)
mark = Image.open(mark_prefix)
if opacity < 1:
mark = reduce_opacity(mark, opacity)
if im.mode != 'RGBA':
im = im.convert('RGBA')
# create a transparent layer the size of the image and draw the
# watermark in that layer.
layer = Image.new('RGBA', im.size, (0,0,0,0))
if position == 'title':
for y in range(0, im.size[1], mark.size[1]):
for x in range(0, im.size[0], mark.size[0]):
layer.paste(mark, (x, y))
elif position == 'scale':
# scale, but preserve the aspect ratio
ratio = min(
float(im.size[0]) / mark.size[0], float(im.size[1]) / mark.size[1])
w = int(mark.size[0] * ratio)
h = int(mark.size[1] * ratio)
mark = mark.resize((w, h))
layer.paste(mark, ((im.size[0] - w) / 2, (im.size[1] - h) / 2))
elif position == POSITION[0]:
#lefttop
position = (PADDING,PADDING)
layer.paste(mark, position)
elif position == POSITION[1]:
#righttop
position = (im.size[0] - mark.size[0]-PADDING, PADDING)
layer.paste(mark, position)
elif position == POSITION[2]:
#center
position = ((im.size[0] - mark.size[0])/2,(im.size[1] - mark.size[1])/2)
layer.paste(mark, position)
elif position == POSITION[3]:
#left bottom
position = (PADDING,im.size[1] - mark.size[1]-PADDING,)
layer.paste(mark, position)
else:
#right bottom (default)
position = (im.size[0] - mark.size[0]-PADDING, im.size[1] - mark.size[1]-PADDING,)
layer.paste(mark, position)
# composite the watermark with the layer
return Image.composite(layer, im, layer)