def mapdraw(args,colorbar):
img = Image.new('RGB',(args['xlen'],args['ylen']),'white')
draw = Draw(img)
for key,value in args['datamap'].iteritems():
draw.point(value,getrgb(str(key)))
img2 = img.resize((args['y'],args['y']), Image.BILINEAR)
imgclr = colorbar.resize((args['colorbar'],img2.size[1]), Image.BILINEAR)
# ===== ENTIRE IMAGE CREATION W/ TEXT=====
imgbox = Image.new('RGB',((300+args['y']+args['colorbar']),(img2.size[1]+200)),args['background'])
imgbox.paste(img2,(100,100))
imgbox.paste(imgclr,((200+img2.size[0]),100))
drawbox = Draw(imgbox)
title = args['title']
titlesize = 50 # future user input
font = truetype("/library/fonts/Arial.ttf",titlesize)
smfontsize = 30 # future user input
smfont = truetype("/library/fonts/Arial.ttf",smfontsize)
titlewidth = font.getsize(title)[0]
drawbox.text(((imgbox.size[0]/2 - titlewidth/2), titlesize/2),title,(0,0,0),font=font)
drawbox.text(((imgbox.size[0] - 95),100),str(args['max']),(0,0,0),font=smfont)
drawbox.text(((imgbox.size[0] - 95),(100 + img2.size[1] - smfontsize)),str(args['min']),(0,0,0),font=smfont)
imgbox.show()
if 'title' in args:
title = args['title']+'_'+str(args['min'])+'_'+str(args['max'])+'.png'
else:
title = 'output_'+str(args['min'])+'_'+str(args['max'])+'.png'
imgbox.save(args['save']+'/'+title)
def postprocess_args(opts, args):
""" Return inputfile, pointsfile, labelsfile, minutes, zoom, fonts after optparser.parse_args().
"""
try:
inputfiles = args[0:]
except IndexError:
raise OptParseError('Input filename is required.')
for inputfile in inputfiles:
if not exists(inputfile):
raise OptParseError('Non-existent input filename: "%(inputfile)s".' % locals())
minutes = opts.minutes
if minutes <= 0:
raise OptParseError('Minutes must be greater than 0: "%(minutes).1f".' % locals())
fonts = {}
fontfile, fontsize = opts.countryfont
try:
fontsize = int(fontsize)
except ValueError:
raise OptParseError('Bad font size for countries: "%(fontsize)s".' % locals())
if not exists(fontfile):
raise OptParseError('Non-existent font filename for counties: "%(fontfile)s".' % locals())
fonts['country'] = truetype(fontfile, fontsize, encoding='unic')
for opt in ('pop25mfont', 'pop250kfont', 'pop50kfont', 'popotherfont'):
population = opt[3:-4]
fontfile, fontsize = getattr(opts, opt)
try:
fontsize = int(fontsize)
except ValueError:
raise OptParseError('Bad font size for population %(population)s: "%(fontsize)s".' % locals())
if not exists(fontfile):
raise OptParseError('Non-existent font filename for population %(population)s: "%(fontfile)s".' % locals())
fonts[population] = truetype(fontfile, fontsize, encoding='unic')
zoom = opts.zoom
countriesfile = opts.countries
pointsfile = opts.points
labelsfile = opts.labels
return countriesfile, inputfiles, pointsfile, labelsfile, minutes, zoom, fonts
def truefonts(self):
if self._truefonts:
return self._truefonts
self._truefonts = tuple(
[truetype(n, s) for n in self._fonts for s in self._font_sizes])
"""truetype returns a font object"""
return self._truefonts
def load_font(font_path=FONT_PATH, font_size=FONT_SIZE):
try:
arial_font = truetype(font_path, font_size)
except OSError:
print(f"Cannot load font {font_path}")
arial_font = None
return arial_font
def _populate_shapes(self):
""" Set values for self._label_shapes, _footprint_shape, and others.
"""
point = Point(self.position.x, self.position.y)
point_buffered = point.buffer(self.radius + self.buffer, 3)
self._point_shape = point.buffer(self.radius, 3)
scale = 10.0
font = truetype(self.fontfile, int(self.fontsize * scale), encoding='unic')
x, y = self.position.x, self.position.y
w, h = font.getsize(self.name)
w, h = w/scale, h/scale
for placement in placements:
label_shape = point_label_bounds(x, y, w, h, self.radius, placement)
mask_shape = label_shape.buffer(self.buffer, 2).union(point_buffered)
self._label_shapes[placement] = label_shape
self._mask_shapes[placement] = mask_shape
unionize = lambda a, b: a.union(b)
self._label_footprint = reduce(unionize, self._label_shapes.values())
self._mask_footprint = reduce(unionize, self._mask_shapes.values())
# number of pixels from the top of the label based on the bottom of a "."
self._baseline = font.getmask('.').getbbox()[3] / scale
def _ensure_valid(
fonts: List[Union[PathLike, str]]) -> List[Union[PathLike, str]]:
"""
A "stupid" checker for fonts. DO NOT USE THIS FUNCTION YOURSELF!
"""
[truetype(n, 50) for n in fonts]
return fonts
def fit_text_in_area(width, height, text):
safe_width = width * 0.9 # 10% border for cleanliness
safe_height = height * 0.9
font_path = os.path.join(settings.STATIC_ROOT, 'font', 'LiberationSans-Regular.ttf')
size = 0
font = truetype(filename=font_path, size=size)
while not font.getsize(text=text)[0] > safe_width and not (font.getsize(text=text)[1] * 1.25) > safe_height:
size += 1
del font
font = truetype(filename=font_path, size=size)
size -= 1
del font
font = truetype(filename=font_path, size=size)
left_border = (width - font.getsize(text=text)[0]) / 2
top_border = height / 2 - font.getsize(text=text)[1] # prefer border on bottom, due to text height inaccuracy
return font, left_border, top_border
def text(self, image, fonts, font_sizes=None, drawings=None, squeeze_factor=0.75, color=None):
color = color if color else self._color
fonts = tuple([truetype(name, size)
for name in fonts
for size in font_sizes or (65, 70, 75)])
draw = Draw(image)
char_images = []
for c in self._text:
font = random.choice(fonts)
c_width, c_height = draw.textsize(c, font=font)
char_image = Image.new('RGB', (c_width, c_height), (0, 0, 0))
char_draw = Draw(char_image)
char_draw.text((0, 0), c, font=font, fill=color)
char_image = char_image.crop(char_image.getbbox())
for drawing in drawings:
d = getattr(self, drawing)
char_image = d(char_image)
char_images.append(char_image)
width, height = image.size
offset = int((width - sum(int(i.size[0] * squeeze_factor)
for i in char_images[:-1]) -
char_images[-1].size[0]) / 2)
for char_image in char_images:
c_width, c_height = char_image.size
mask = char_image.convert('L').point(lambda i: i * 1.97)
image.paste(char_image,
(offset, int((height - c_height) / 2)),
mask)
offset += int(c_width * squeeze_factor)
return image
def create_noise_chars_using_mask(image, char, background, number):
width, height = image.size
font = truetype(random.choice(DEFAULT_FONTS), 30)
draw = Draw(image)
w, h = draw.textsize(char, font=font)
x = random.randint(0, int(8 * width / 9))
y = random.randint(0, int(7 * height / 10))
while number:
im = Image.new('RGBA', (w, h))
color = random_color(10, 200, random.randint(220, 255))
dx = 0
dy = 0
Draw(im).text((dx, dy), char, font=font, fill=color)
Draw(im).text((dx + 1, dy + 1), char, font=font, fill=color)
Draw(im).text((dx - 1, dy - 1), char, font=font, fill=color)
im = im.rotate(random.uniform(-45, 45), Image.BILINEAR, expand=1)
im = im.crop(im.getbbox())
alpha = im.convert('RGBA').split()[-1]
bg = Image.new("RGBA", im.size, background + (255, ))
bg.paste(im, mask=alpha)
im = bg
# mask = im.convert('L').point(table)
image.paste(im, (x, y))
number -= 1
return image
def make_pic(text):
ttfont = truetype(font, font_size) # 这里我之前使用Arial.ttf时不能打出中文，用华文细黑就可以
image = Image.new(imgmode, imgsize, background)
draw = Draw(image)
images = []
for c in text:
images.append(_draw_character(c, draw, ttfont))
#
text_width = sum([im.size[0] for im in images])
# width = max(text_width, imgsize[0])
# image = image.resize((width, imgsize[1]))
average = int(text_width / len(text))
rand = int(0.25 * average)
offset = int(average * 0.1)
#
for im in images:
w, h = im.size
if offset < 10:
offset = 10
offseth = int((imgsize[1] - h) / 2) + random.randint(-4, 4)
image.paste(im, (offset, offseth))
offset = offset + w + random.randint(-rand, 0)
# create_noise_curve(image, color)
# draw.text((10, 2), text, fill=color, font=ttfont)
image.save('out5.png')
def text(self, image, fonts, font_sizes=None, drawings=None, squeeze_factor=0.75, color=None):
color = color if color else self._color
fonts = tuple([truetype(name, size)
for name in fonts
for size in font_sizes or (65, 70, 75)])
draw = Draw(image)
char_images = []
for c in self._text:
font = random.choice(fonts)
c_width, c_height = draw.textsize(c, font=font)
char_image = Image.new('RGB', (c_width, c_height), (0, 0, 0))
char_draw = Draw(char_image)
char_draw.text((0, 0), c, font=font, fill=color)
char_image = char_image.crop(char_image.getbbox())
for drawing in drawings:
d = getattr(self, drawing)
char_image = d(char_image)
char_images.append(char_image)
width, height = image.size
offset = int((width - sum(int(i.size[0] * squeeze_factor)
for i in char_images[:-1]) -
char_images[-1].size[0]) / 2)
for char_image in char_images:
c_width, c_height = char_image.size
mask = char_image.convert('L').point(lambda i: i * 1.97)
image.paste(char_image,
(offset, int((height - c_height) / 2)),
mask)
offset += int(c_width * squeeze_factor)
return image
def create_noise_chars_using_mask(image, char, number):
width, height = image.size
font = truetype('../data/DroidSansMono.ttf', 30)
draw = Draw(image)
w, h = draw.textsize(char, font=font)
x = random.randint(0, int(8 * width / 9))
y = random.randint(0, int(7 * height / 10))
while number:
im = Image.new('RGBA', (w, h))
color = random_color(10, 200, random.randint(220, 255))
dx = 0
dy = 0
Draw(im).text((dx, dy), char, font=font, fill=color)
Draw(im).text((dx + 1, dy + 1), char, font=font, fill=color)
Draw(im).text((dx - 1, dy - 1), char, font=font, fill=color)
im = im.rotate(random.uniform(-45, 45), Image.BILINEAR, expand=1)
im = im.crop(im.getbbox())
mask = im.convert('L').point(table)
image.paste(im, (x, y), mask=mask)
number -= 1
return image
def _populate_shapes(self):
""" Set values for self._label_shapes, _footprint_shape, and others.
"""
point = Point(self.position.x, self.position.y)
point_buffered = point.buffer(self.radius + self.buffer, 3)
self._point_shape = point.buffer(self.radius, 3)
scale = 10.0
font = truetype(self.fontfile, int(self.fontsize * scale), encoding='unic')
x, y = self.position.x, self.position.y
w, h = font.getsize(self.name)
w, h = w/scale, h/scale
for placement in placements:
label_shape = point_label_bounds(x, y, w, h, self.radius, placement)
mask_shape = label_shape.buffer(self.buffer, 2).union(point_buffered)
self._label_shapes[placement] = label_shape
self._mask_shapes[placement] = mask_shape
unionize = lambda a, b: a.union(b)
self._label_footprint = reduce(unionize, self._label_shapes.values())
self._mask_footprint = reduce(unionize, self._mask_shapes.values())
# number of pixels from the top of the label based on the bottom of a "."
self._baseline = font.getmask('.').getbbox()[3] / scale
def truefonts2(self):
self._truefonts2 = tuple([
truetype(n, random.randint(42,47))
for n in self._fonts2
])
return self._truefonts2
def text(fonts,
font_sizes=None,
drawings=None,
color: Union[str, Callable] = '#5C87B2',
squeeze_factor=0.8):
""" 向验证码上写文字
:param fonts: ttf 字体文件，Iterable
:param font_sizes: 字体大小，Iterable
真正的字体是 fonts 和 font_sizes 的笛卡尔积
:param drawings: 文字变换(混淆)方法，每生成一个字母，所有 drawings 都会变换这个字母
:param color: 文字颜色，或者是一个返回颜色的函数 (例如随机颜色)
:param squeeze_factor: 挤压的比例，这个值越低，验证码重叠程度越高
"""
fonts = tuple(
truetype(name, size) for name in fonts
for size in font_sizes or (65, 70, 75))
if not callable(color):
c = getrgb(color)
def color():
return c
def drawer(image_, text_):
draw = Draw(image_)
char_images = []
for c_ in text_:
font = random.choice(fonts)
c_width, c_height = draw.textsize(c_, font=font)
# char_image = Image.new('RGB', (c_width, c_height), (0, 0, 0))
o_width, o_height = font.getoffset(c_)
char_image = Image.new(mode='RGB',
size=(c_width + o_width,
c_height + o_height),
color=(0, 0, 0))
char_draw = Draw(char_image)
char_draw.text((0, 0), c_, font=font, fill=color())
char_image = char_image.crop(char_image.getbbox())
for drawing in drawings:
char_image = drawing(char_image)
char_images.append(char_image)
width, height = image_.size
offset_ = int(
(width -
sum(int(i.size[0] * squeeze_factor)
for i in char_images[:-1]) - char_images[-1].size[0]) / 2)
# 将单个字符图像画在验证码上
for char_image in char_images:
c_width, c_height = char_image.size
mask = char_image.convert('L').point(lambda i: i * 1.97)
image_.paste(char_image, (offset_, int((height - c_height) / 2)),
mask)
offset_ += int(c_width * squeeze_factor)
return image_
return drawer
def __init__(self, text, font_path="msyh.ttc", font_size=14):
self.font = truetype(font=font_path, size=font_size)
self.width, self.height = self.get_danmu_size(text)
self.height_range = [0, 720]
self.width_range = [0, 1920]
self.lines_start_y = list(range(*(self.height_range + [self.height])))
self.lines_width_used = [[y, 0] for y in self.lines_start_y]
self.contents = []
def bold_italic(self, size=10, index=0, encoding="", layout_engine=None):
if self.bold_italic_path is None:
return None
return truetype(font=self.bold_italic_path,
size=size,
index=index,
encoding=encoding,
layout_engine=layout_engine)
def normal(self, size=10, index=0, encoding="", layout_engine=None):
if self.normal_path is None:
return None
return truetype(font=self.normal_path,
size=size,
index=index,
encoding=encoding,
layout_engine=layout_engine)
def truefonts(self):
if self._truefonts:
return self._truefonts
self._truefonts = tuple([
truetype(n, FONT_SIZE)
for n in self._fonts
])
"""truetype returns a font object"""
return self._truefonts
def truefonts(self):
if self._truefonts:
return self._truefonts
self._truefonts = tuple([
truetype(n, s)
for n in self._fonts
for s in self._font_sizes
])
return self._truefonts
def truefonts(self):
if self._truefonts:
return self._truefonts
self._truefonts = tuple([
truetype(n, s)
for n in self._fonts
for s in self._font_sizes
])
return self._truefonts
def get_font(path: str = "../resources/fonts/font.ttf",
size: int = 36) -> FreeTypeFont:
"""
Get the specified font.
:param path: The path to the location of the font's TTF file.
:param size: The size to use for the font.
:return: The font.
"""
return truetype(path, size)
def fit_text_in_area(width, height, text):
safe_width = width * 0.9 # 10% border for cleanliness
safe_height = height * 0.9
font_path = os.path.join(settings.STATIC_ROOT, 'font',
'LiberationSans-Regular.ttf')
size = 0
font = truetype(filename=font_path, size=size)
while not font.getsize(text=text)[0] > safe_width and not (
font.getsize(text=text)[1] * 1.25) > safe_height:
size += 1
del font
font = truetype(filename=font_path, size=size)
size -= 1
del font
font = truetype(filename=font_path, size=size)
left_border = (width - font.getsize(text=text)[0]) / 2
top_border = height / 2 - font.getsize(
text=text)[1] # prefer border on bottom, due to text height inaccuracy
return font, left_border, top_border
def truefonts(self):
#if self._truefonts:
# return self._truefonts
self._truefonts = tuple([
truetype(n, random.randint(45,55))
#truetype(n, s)
for n in self._fonts
#for s in self._font_sizes
])
return self._truefonts
def __init__(self, sch, plat, dest, exp, call, op):
self.sch = sch
self.plat = plat
self.dest = dest
self.exp = exp
self.call = call
self.op = op
self.colour = 'yellow'
self.font = truetype(
path.dirname(path.realpath(__file__)) + '/text.ttf', 14)
def truefonts(self):
"""
属性方法
组合所有字体和字体大小
"""
if self._truefonts:
return self._truefonts
self._truefonts = tuple(
[truetype(n, s) for n in self._fonts for s in self._font_sizes])
return self._truefonts
def truefonts(self):
#if self._truefonts:
# return self._truefonts
self._truefonts = tuple([
# truetype(n, random.randint(40,55))
truetype(n, 35) #字体大小
for n in self._fonts
#for s in self._font_sizes
])
return self._truefonts
def image_4():
current_time = strftime("%H:%M:%S", localtime())
im = Image.new('RGB', (256, 64))
draw = ImageDraw.Draw(im)
draw.text((13, 14),
current_time,
fill='yellow',
font=truetype(time_font, 50))
with canvas(device, background=im) as draw:
pass
def text(self,
fonts,
font_sizes=None,
drawings=None,
color='#FFFFFF',
squeeze_factor=0.5,
border=2,
b_color="#000000"):
fonts = tuple([
truetype(name, size) for name in fonts
for size in font_sizes or (65, 70, 75)
])
if not callable(color):
c = getrgb(color)
def color():
return c
if not callable(b_color):
bc = getrgb(b_color)
def b_color():
return bc
def drawer(image, text):
draw = Draw(image)
char_images = []
for c in text:
font = random.choice(fonts)
c_width, c_height = draw.textsize(c, font=font)
char_image = Image.new('RGBA', (c_width + 1, c_height + 1),
"black")
char_draw = Draw(char_image)
self._outline(char_draw, 0, 0, c, font, "gray", border)
char_draw.text((0, 0), c, font=font, fill="black")
char_image = char_image.crop(char_image.getbbox())
for drawing in drawings:
char_image = drawing(char_image)
char_image = char_image.resize((char_image.width, 42))
char_images.append(char_image)
width, height = image.size
offset = int((width - sum(
int(i.size[0] * squeeze_factor)
for i in char_images[:-1]) - char_images[-1].size[0]) / 2)
for char_image in char_images:
c_width, c_height = char_image.size
mask = char_image.convert('L').point(lambda i: i * 1.97)
image.paste(char_image, (offset, int((height - c_height) / 2)),
mask)
offset += int(c_width * squeeze_factor)
self._remove_white_background_with_chops(image)
return image
return drawer
def gen_img(font_name, font_size, text, img_size):
font = truetype(font_name + ".ttf", font_size)
print(font.getsize("By"))
width, height = img_size
img = new("1", (width, height), 255)
drawing = Draw(img)
drawing.text((10, 10), text, fill=0, font=font)
img = img.convert("L")
img = np.asarray(img, dtype=np.uint8)
return img
def make_text(
text: str,
box=(0, 0),
font_path='',
init_font_size=76,
color=(0, 0, 0, 255),
stroke=None, # stroke can be a color tuple
align='left',
emojis={},
instance=''):
if contains_emojis(text, emojis):
# fancy rendering enabled
# redirect to fit_text_with_emojis_in_box()
return make_emoji_text(text,
emojis=emojis,
instance=instance,
box=box,
font_path=font_path,
color=color,
stroke=stroke,
align=align)
canvas = Image.new('RGBA', box, color=(255, 255, 255, 0))
draw = Draw(canvas)
textsize = (box[0] + 1, box[1] + 1)
font_size = init_font_size # max font size is 72; decrease by 4 until fit
while textsize[0] > box[0] or textsize[1] > box[1]: # doesn't fit
if 0 < font_size <= 16:
font_size -= 1
elif 16 < font_size < 32:
font_size -= 2
elif font_size >= 32:
font_size -= 4
else:
break
font = truetype(font_path, size=font_size)
# try to fit in the horizontal boundary
wrapped = wrap_text(text, box[0], font)
textsize = draw.multiline_textsize(wrapped, font=font)
# when wrapped text fits in box, loop will exit, and font is remembered
draw.multiline_text(
(0, 0),
wrapped,
fill=color if stroke is None else WHITE,
font=font,
stroke_fill=stroke,
stroke_width=(max(font_size // 20, 2) if stroke is not None else 0),
align=align)
return canvas
def create_noise_chars_without_mask(image, char, number):
w, h = image.size
font = truetype('../data/DroidSansMono.ttf', 30)
draw = Draw(image)
while number:
x = random.randint(0, int(8 * w / 9))
y = random.randint(0, int(7 * h / 10))
color = random_color(10, 200, random.randint(220, 225))
draw.text((x, y), char, fill=color, font=font)
draw.text((x + 1, y + 1), char, fill=color, font=font)
draw.text((x - 1, y - 1), char, fill=color, font=font)
number -= 1
return image
async def write_text():
if not len("".join(str(_) for _ in msg)) > line_limit:
try:
file_dir = "Assets\\PhilosophyImages"
file = choice(
[_ for _ in listdir(file_dir)
if path.isfile(path.join(file_dir, _))])
def center_text(image, text, color, font):
draw = Draw(image)
width, height = image.size
text_width, text_height = draw.textsize(text, font)
position = (
(width - text_width) / 2 + 100,
((height - (text_height * 1.5)) / 2)
)
draw.text(position, text, color, font)
image.save("Assets\\PhilosophyImages\\temporary.png")
center_text(image=op_img(f"{file_dir}/{file}"),
text="\n".join(wrap(text=user_text, width=wrap_limit)),
color=(255, 255, 255),
font=truetype("times", 16))
await message.channel.send(
file=File(
fp=open("Assets\\PhilosophyImages\\temporary.png", "rb")
)
)
# No "attach_files" permission.
except Forbidden:
await message.channel.send(
embed=Embed(
title="Permissões insuficientes:",
description="*Não tenho `attach_files` ativada no canal ou no "
"meu cargo*.",
color=0xFFFF00
)
)
else:
await message.channel.send(
embed=Embed(
title="**Limite máximo atingido**",
description="Você ultrapassou o limite de caracteres permitido.",
color=0xFFFF00
)
)
def create_noise_chars_without_mask(image, char, number):
w, h = image.size
font = truetype(random.choice(DEFAULT_FONTS), 30)
draw = Draw(image)
while number:
x = random.randint(0, int(8 * w / 9))
y = random.randint(0, int(7 * h / 10))
color = random_color(120, 220, random.randint(20, 55))
draw.text((x, y), char, fill=color, font=font)
draw.text((x + 1, y + 1), char, fill=color, font=font)
draw.text((x - 1, y - 1), char, fill=color, font=font)
number -= 1
return image
def image_3():
scroller()
current_time = strftime("%H:%M:%S", localtime())
im = Image.new('RGB', (256, 64))
draw = ImageDraw.Draw(im)
draw.text((0, 0), '1st', fill='yellow', font=data[0].font)
draw.text((30, 0),
data[0].generate_card(),
fill='yellow',
font=data[0].font)
draw.text((x, 15), data[0].call, fill='yellow', font=data[0].font)
draw.text((92, 48),
current_time,
fill='yellow',
font=truetype(time_font, 17))
with canvas(device, background=im) as draw:
pass
def draw_text(image, text, font_size):
font = truetype(join(current_dir, 'static/font.ttf'), font_size)
color = '#5C87B2'
draw = Draw(image)
char_images = []
for ch in text:
c_width, c_height = draw.textsize(ch, font=font)
char_image = Image.new('RGB', (c_width, c_height), (0, 0, 0))
char_draw = Draw(char_image)
char_draw.text((0, 0), ch, font=font, fill=color)
char_image = char_image.crop(char_image.getbbox())
char_images.append(char_image)
width, height = image.size
total = len(char_images)
for i, char_image in enumerate(char_images):
c_width, c_height = char_image.size
mask = char_image.convert('L').point(lambda i: i * 1.97)
upper = int((height - c_height) / 2)
left = int((width * (i + 1) / (total + 1)) - c_width / 2)
image.paste(char_image, (left, upper), mask)
return image
def captcha_text(fonts, font_sizes=None, drawings=None, color='#5C87B2',
squeeze_factor=0.8):
fonts = tuple([truetype(name, size)
for name in fonts
for size in font_sizes or (65, 70, 75)])
if not callable(color):
c = getrgb(color)
color = lambda: c
def drawer(image, text):
draw = Draw(image)
char_images = []
for c in text:
font = random.choice(fonts)
c_width, c_height = draw.textsize(c, font=font)
c_height *= 2
char_image = Image.new('RGB', (c_width, c_height), (0, 0, 0))
char_draw = Draw(char_image)
char_draw.text((0, 0), c, font=font, fill=color())
char_image = char_image.crop(char_image.getbbox())
for drawing in drawings:
char_image = drawing(char_image)
char_images.append(char_image)
width, height = image.size
offset = int((width - sum(int(i.size[0] * squeeze_factor)
for i in char_images[:-1])
- char_images[-1].size[0]) / 2)
for char_image in char_images:
c_width, c_height = char_image.size
mask = char_image.convert('L').point(lambda i: i * 1.97)
image.paste(char_image,
(offset, int((height - c_height) / 2)),
mask)
offset += int(c_width * squeeze_factor)
return image
return drawer
def map_gen(is_demo):
cur_dir = os.path.dirname(os.path.realpath('__file__'))
filename = os.path.join(cur_dir, 'data/map.png' if is_demo else '../data/map.png')
image = Image.open(filename)
width, height = image.size
# левая верхняя точка
lon_l = -122.51456
lat_l = 37.81155
# правая нижняя точка
lon_r = -122.37173
lat_r = 37.69238
lx = lon2x(lon_l)
ly = lat2y_m(lat_l)
rx = lon2x(lon_r)
ry = lat2y_m(lat_r)
real_width = math.fabs(rx - lx)
real_height = math.fabs(ry - ly)
# широта долгота в точки на картинке
def calc_on_map_point(lon, lat):
px = lon2x(lon)
py = lat2y_m(lat)
# реальные точки, но относительно левого края картинки
local_x = math.fabs(px - lx)
local_y = math.fabs(py - ly)
# точки на картинке (делим относительную точку на реальный размер и умножаем на размер картинки)
img_x = (local_x / real_width) * width
img_y = (local_y / real_height) * height
return (img_x, img_y)
rad = 2
def point_to_ellipse(p):
return p[0] - rad, p[1] - rad, p[0] + rad, p[1] + rad
x = [] # longitudes
y = [] # latitudes
print("Загружаем датасет")
df = load('data/train.csv.zip' if is_demo else '../data/train.csv.zip')
print("Загружено")
i = Image.new("RGBA", (width, height), 'white')
d = ImageDraw.Draw(i, "RGBA")
i.paste(image)
# draw = ImageDraw.Draw(image, "RGBA")
draw = d
image = i
def top_crimes(df, items=0):
df.columns = df.columns.map(operator.methodcaller('lower'))
by_col = df.groupby("category")
col_freq = by_col.size()
col_freq.index = col_freq.index.map(string.capwords)
col_freq.sort(ascending=False, inplace=True)
cols = [col for col in col_freq.index]
cols = cols[0:1] + cols[3:]
return cols[:items]
print("Достаём топ-5 преступлений")
top = top_crimes(df, items=5)
opacity = 220
# color_list = ['red', 'green', 'blue', 'purple', 'orange', 'pink', 'black', 'brown']
color_list = [(255, 0, 0, opacity), (0, 255, 0, opacity), (0, 0, 255, opacity), (255, 127, 80, opacity),
(139, 0, 139, opacity), (255, 105, 180, opacity), (0, 0, 0, opacity),
(188, 143, 143, opacity)]
colors_map = {top[i]: color_list[i] for i in range(len(top))}
print("Начинаем рисовать на карте")
length = df.shape[0]
if is_demo:
length = int(length * 0.15) #нарисуем 100,000 точек, вместо всех
last_percent = -1
for i in range(length):
percent = int((i / length) * 100)
if percent > last_percent:
last_percent = percent
print(str(percent) + "%")
print(str(i) + " строка")
first_row = df.ix[i]
category = string.capwords(first_row["category"])
if category in top:
lon = first_row["x"]
lat = first_row["y"]
p = calc_on_map_point(lon, lat)
color = colors_map[category]
draw.ellipse(point_to_ellipse(p), fill=color, outline=color)
# рисуем легенду
lineheight = 35
padding = 20
space = 20
legend_rad = 10
font = truetype(font="times.ttf", size=15)
legend_right = width / 3
legend_down = (len(top)) * lineheight + padding
draw.rectangle((0, 0, legend_right, legend_down), 'white', 'black')
for i in range(len(top)):
x = padding
y = i * lineheight + padding
category = top[i]
color = colors_map[category]
draw.ellipse((x, y, x + (2 * legend_rad), y + (2 * legend_rad)), fill=color, outline='black')
draw.text((x + (2 * legend_rad) + space, y), translate(category, "en", "ru"), fill='black', font=font)
image.save('test.png', 'PNG')
if __name__ == '__main__':
parser = ArgumentParser(description="Extract glyph images from a font.")
parser.add_argument('glyphset', choices=sets.keys(),
help="glyphs collection key")
parser.add_argument('font', nargs='?', default='dejavu-serif',
help="path to a .ttf file")
parser.add_argument('size', type=int, nargs='?', default=14,
help="font size")
args = parser.parse_args()
folder = join('glyphs', args.glyphset)
try:
mkdir(folder)
except FileExistsError:
pass
try:
args.font = fonts[args.font]
except KeyError:
pass
font = truetype(args.font, args.size)
available_characters = set(c[0] for t in TTFont(args.font)['cmap'].tables
for c in t.cmap.items())
characters = set(sets[args.glyphset]) & available_characters
for character in characters:
image = Image()._new(font.getmask(chr(character)))
image.save(join(folder, '{}.png'.format(character)))
print("Extracted {} glyphs".format(len(characters)))
def grafh_to_image(self):
#d.text((10, 10), "Hello World", fill=(0, 0, 0), font=f)
ae = self.arestas_externas
segmentos = []
for k, v in ae.items():
for a in v:
segmentos.append(
[
0, list(ae.keys()).index(k),
0, list(ae.keys()).index(a)
]
)
def cmp_to_key(mycmp):
'Convert a cmp= function into a key= function'
class K:
def __init__(self, obj, *args):
self.obj = obj
def __lt__(self, other):
return mycmp(self.obj, other.obj) < 0
def __gt__(self, other):
return mycmp(self.obj, other.obj) > 0
def __eq__(self, other):
return mycmp(self.obj, other.obj) == 0
def __le__(self, other):
return mycmp(self.obj, other.obj) <= 0
def __ge__(self, other):
return mycmp(self.obj, other.obj) >= 0
def __ne__(self, other):
return mycmp(self.obj, other.obj) != 0
return K
def sort_seg(a, b):
if a[3] - a[1] > b[3] - b[1]:
return 1
if a[3] - a[1] < b[3] - b[1]:
return -1
if a[1] > b[1]:
return 1
if a[1] < b[1]:
return -1
if a[3] > b[3]:
return 1
if a[3] < b[3]:
return -1
return 0
print(segmentos)
segmentos.sort(key=cmp_to_key(sort_seg))
print(segmentos)
"""
x_max = 0
for p in seg:
x = 0
for pn in seg:
if p == pn:
continue
if pn[1] < p[3] and pn[3] > p[1] and pn[0] == p[0]:
x += 1
pn[0] = pn[2] = x
if x > x_max:
x_max = x"""
ws = segmentos
segmentos = [[]]
while ws:
s = ws.pop(0)
for gs in segmentos:
ok = True
for i in gs:
ok = i[1] < s[1] and i[3] < s[1] or i[1] > s[3] and i[3] > s[3]
if not ok:
break
if ok:
gs.append(s)
break
if segmentos[-1]:
segmentos.append([])
x = 0
seg = []
for gs in segmentos:
for s in gs:
s[0] = x
s[2] = x
seg.append(s)
x += 1
x_max = x
my = 50
mx = 80
x = mx
y = my
r = 5
dx = 50
dy = 10
img = Image.new('RGB', (x_max * dx * 2 + mx, len(self.graph) * 50),
color=(255, 255, 255))
f = truetype(
font='/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',
size=15)
d = ImageDraw.Draw(img)
pos = 0
for node, value in self.graph.items():
d.ellipse((x - r, y - r, x + r, y + r), fill=(0, 0, 0, 255))
d.text((20, y - r), str(node), fill=(0, 0, 0), font=f)
#d.text((mx, y + r), str(pos), fill=(0, 0, 0), font=f)
y += 50 - dy
pos += 1
for p in seg:
y = my - dy
pv = (
p[0] * dx + mx + dx,
p[1] * y + y + 2 * r,
p[2] * dx + mx + dx,
p[3] * y + y + 2 * r # - p[0] * r * 4
)
ph1 = (
mx,
p[1] * y + y + 2 * r,
p[0] * dx + mx + dx,
p[1] * y + y + 2 * r,
)
ph2 = (
mx,
p[3] * y + y + 2 * r,
p[2] * dx + mx + dx,
p[3] * y + y + 2 * r # - p[0] * r * 4,
)
d.line(ph1, fill=128, width=1)
d.line(pv, fill=128, width=1)
d.line(ph2, fill=128, width=1)
img.save("/home/leandro/teste.png")
label = args.label[0].decode('utf-8')
if args.name:
filename = args.name
else:
filename = 'button-small-%s.png' % label.lower().replace(' ', '-')
# Hintergrund zusammenbauen
gradients = Image.open('generate-button-small.png')
y = 0
height = 23
background = gradients.crop((0, y, 200, height))
right = gradients.crop((203, 0, 208, height))
# Font laden und rausbekommen, wie gross der Button werden muss
ttf = '/Library/Fonts/Arial Narrow Bold.ttf'
font = truetype(ttf, 12, encoding='unic')
text_width, _ = font.getsize(label)
width = text_width + 2 * args.padding
# jetzt den Hintergrund in den Button reinkopieren
button = Image.new('RGBA', (width, height * 2))
button.paste(background, (0, 0))
button.paste(flip(background), (0, height))
button.paste(right, (width-5, 0))
button.paste(flip(right), (width-5, height))
# dann die Beschriftung reinmalen
draw = Draw(button)
draw.text((args.padding, 0+3), label, font=font, fill=args.text_color)
draw.text((args.padding, 23+4), label, font=font, fill=args.text_color)
def annotate(image, text):
draw = ImageDraw(image)
font = truetype("Helvetica.otf", 16)
draw.text((0, 0), text, (255, 255, 255), font=font)
