def write_text(cls,
canvas: ImageDraw.Draw,
fonts: 'FontsSize',
text: str,
pos: Optional[tuple] = (0, 0),
*args: list,
**kwargs: dict) -> tuple:
x, y = pos
lines_x = []
text_x, text_y = 0, 0
line_y = 0
for char in text:
if char == '\n':
lines_x.append(text_x)
x, y = (pos[0], y + line_y)
text_x, text_y = (0, text_y + line_y)
line_y = 0
continue
font, y_minus = fonts.detect(char)
char_x, char_y = canvas.textsize(char, font=font)
text_x += char_x
if text_y < char_y:
text_y = char_y
if line_y < char_y:
line_y = char_y
canvas.text((x, y - y_minus), char, font=font, *args, **kwargs)
x, y = ((x + char_x), y)
final_x = max(lines_x) if lines_x else text_x
final_y = text_y
return final_x, final_y
def draw_text( data, text, color = 255, pos = 'lr' ):
from PIL.Image import fromarray
from PIL.ImageDraw import Draw
from PIL import ImageFont
from numpy import asarray
font = ImageFont.load_default()
image = fromarray( data )
draw = Draw( image )
w, h = draw.textsize( text, font = font )
position = {
'ul': lambda iw, ih, tw, th: ( 2, 0 ),
'ur': lambda iw, ih, tw, th: ( iw - tw - 2, 0 ),
'll': lambda iw, ih, tw, th: ( 2, ih - th ),
'lr': lambda iw, ih, tw, th: ( iw - tw - 2, ih - th ),
}
pos = position[ pos ]( data.shape[ 1 ], data.shape[ 0 ], w, h )
draw.text( pos, text, fill = color, font = font )
del draw
return asarray( image )
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
def draw_text(data, text, color=255, pos='lr'):
from PIL.Image import fromarray
from PIL.ImageDraw import Draw
from PIL import ImageFont
from numpy import asarray
font = ImageFont.load_default()
image = fromarray(data)
draw = Draw(image)
w, h = draw.textsize(text, font=font)
position = {
'ul': lambda iw, ih, tw, th: (2, 0),
'ur': lambda iw, ih, tw, th: (iw - tw - 2, 0),
'll': lambda iw, ih, tw, th: (2, ih - th),
'lr': lambda iw, ih, tw, th: (iw - tw - 2, ih - th),
}
pos = position[pos](data.shape[1], data.shape[0], w, h)
draw.text(pos, text, fill=color, font=font)
del draw
return asarray(image)
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_
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 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
async def draw_player(
draw: ImageDraw.Draw,
composite: Image,
player: Player,
character: Image,
rank: Image,
y_offset: int,
) -> None:
ready = is_ready if player.is_ready() else not_ready
voice = voice_on if player.is_in_voice() else voice_off
y_offset += PLAYER_ONE_START
composite.paste(rank, (88, y_offset), rank)
composite.paste(ready, (132, y_offset + 11), ready)
composite.paste(voice, (155, y_offset + 5), voice)
composite.paste(character, (183, y_offset))
try:
profile = await player.get_avatar()
composite.paste(profile.resize((19, 19)), (226, y_offset + 8))
except Exception:
pass
draw.text(
(255, y_offset + 11),
player.get_name(),
font=name_font,
fill=(81, 81, 81, 255),
)
def __imgBox(self, obj_list, image, im_width, im_height):
im = image.convert('RGBA')
drawn = Draw(im)
fontsize = im_height * 0.01
font = ImageFont.truetype('arial.ttf', int(round(fontsize)))
coords = []
for inst in obj_list:
label = inst.tag_name
probability = inst.probability
x0, y0 = inst.bounding_box.left * im_width, inst.bounding_box.top * im_height
x1, y1 = x0 + inst.bounding_box.width * im_width, y0 + inst.bounding_box.height * im_height
xC, yC = abs(x0 + x1) / 2, abs(y0 + y1) / 2
xC, yC = self.__img_to_drone_coords(xC, yC, im_width, im_height)
coords.append((xC, yC))
drawn.rectangle([(x0, y0), (x1, y1)], outline=(255, 0, 0, 255))
drawn.text((x0, y0),
f'{label}: {round(probability, 3)}; ({xC}, {yC})',
fill=(0, 0, 0, 255),
font=font)
return im, coords
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 generate_image_from_word(self, word, watermark=None, font_color=(140, 140, 140), background=(255, 255, 255, 0)):
font_type = make_font_type(self.font_path, self.font_size)
image_width = self.image_size[0]
image_height = self.image_size[1]
image = Image.new('RGBA', self.image_size, background)
draw = Draw(image)
# Draw the word.
word_width, word_height = draw.textsize(word, font=font_type)
width_offset = int((image_width - word_width) / 2)
height_offset = int((image_height - word_height) / 2)
draw.text((width_offset, height_offset), word, font=font_type, fill=font_color)
# Do random distortion.
image = np.asarray(image)
image = elastic_transformations(image, alpha=1200, sigma=40)
image = Image.fromarray(image)
color = (112, 112, 112)
self._create_noise_dots(image, color=color, n_min=450, n_max=500)
self._create_noise_curves(image, color=color, width_min=1, width_max=3, n_min=8, n_max=12)
if watermark:
self._add_watermark(image, watermark, font_color=(112, 112, 112))
image = image.convert('RGB')
return image
def draw_text(text, font_spec, text_color, xy=None, anchor=None,
box_color=None, box_padding=0, border_color=None, border_width=0,
image=None):
"""Draws centered text on an image, optionally in a box."""
draw = Draw(image)
text_size = font_spec['size']
font = ImageFont.truetype(font_spec['file'], size=text_size)
# Measure the width of each character.
character_widths = []
for character in text:
# Override the measured width, if specified.
width_overrides = font_spec['width_overrides']
if character in width_overrides.keys():
character_width = width_overrides[character]
else:
character_width, _ = draw.textsize(character, font)
character_widths.append(character_width)
text_width = sum(character_widths)
# If any xy is specified, use it.
text_height = font_spec['height']
if xy:
x = xy[0] - text_width // 2
y = xy[1] - text_height // 2
# If any anchor is specified, adjust the xy.
if anchor == 'center':
x = image.width // 2 - text_width // 2
y = image.height // 2 - text_height // 2
elif anchor == 'center_x':
x = image.width // 2 - text_width // 2
elif anchor == 'center_y':
y = image.height // 2 - text_height // 2
elif anchor == 'bottom_right':
x = image.width - box_padding - border_width - text_width
y = image.height - box_padding - border_width - text_height
# Draw the box background and border.
box_xy = [x - box_padding,
y - box_padding,
x + text_width + box_padding,
y + text_height + box_padding]
border_xy = [box_xy[0] - border_width,
box_xy[1] - border_width,
box_xy[2] + border_width,
box_xy[3] + border_width]
if border_color:
draw.rectangle(border_xy, border_color)
if box_color:
draw.rectangle(box_xy, box_color)
# Draw the text character by character.
y -= font_spec['y_offset']
for index in range(len(text)):
character = text[index]
draw.text((x, y), character, text_color, font)
x += character_widths[index]
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")
def render(self, draw: ImageDraw.Draw):
title = "SETUP MODE"
id = self.states['deviceId']
# Display Arm State
w, h = draw.textsize(title)
draw.text(((128 - w) / 2, (32 - h) / 2), title, font=font, fill=255)
# Display Id
w, h = draw.textsize(id)
draw.text(((128 - w) / 2, 20), id, font=font, fill=255)
def inimagehandler(self, code, message, params):
im = new('RGBA', (int(params['width']), int(params['height'])))
im.putalpha(new('1', (int(params['width']), int(params['height']))))
draw = Draw(im)
for count, line in enumerate(message.strip().split('\n')):
draw.text((12, 15 * (count + 1)), line, fill='#000000')
fh = StringIO()
im.save(fh, PIL_TYPE_MAPPING[params['format']])
fh.seek(0)
return Response(params['format'], fh.read())
def inimagehandler(self, code, message, params):
im = new('RGBA', (int(params['width']), int(params['height'])))
im.putalpha(new('1', (int(params['width']), int(params['height']))))
draw = Draw(im)
for count, line in enumerate(message.strip().split('\n')):
draw.text((12,15*(count+1)), line, fill='#000000')
fh = StringIO()
im.save(fh, PIL_TYPE_MAPPING[params['format']])
fh.seek(0)
return Response(params['format'], fh.read())
def inimagehandler(self, code, message, params):
im = new("RGBA", (int(params["width"]), int(params["height"])))
im.putalpha(new("1", (int(params["width"]), int(params["height"]))))
draw = Draw(im)
for count, line in enumerate(message.strip().split("\n")):
draw.text((12, 15 * (count + 1)), line, fill="#000000")
fh = StringIO()
im.save(fh, PIL_TYPE_MAPPING[params["format"]])
fh.seek(0)
return Response(params["format"], fh.read())
def _add_watermark(self, image, text, font_color=(140, 140, 140)):
watermark_font_type = make_font_type(self.font_path, self.watermark_font_size)
draw = Draw(image)
w, h = draw.textsize(text, font=watermark_font_type)
dx = (image.width - w) - 4.5
dy = image.height - h - 0
draw.text((dx, dy), text, font=watermark_font_type, fill=font_color)
return image
def get_classification(self, inp_image):
"""Determines the color of the traffic light in the image
Args:
image (cv::Mat): image containing the traffic light
Returns:
int: ID of traffic light color (specified in styx_msgs/TrafficLight)
"""
image_array = np.array(inp_image)
image = np.reshape(image_array,
(1, image_array.shape[0], image_array.shape[1],
image_array.shape[2]))
results = self.sess.run(
[
self.graph.get_tensor_by_name('prefix/detection_boxes:0'),
self.graph.get_tensor_by_name('prefix/detection_scores:0'),
self.graph.get_tensor_by_name('prefix/detection_classes:0')
], {self.graph.get_tensor_by_name('prefix/image_tensor:0'): image})
pilimg = Image.fromarray(image_array)
classes = []
for boxid in range(len(results[0][0])):
if results[1][0][boxid] > 0.5:
predclass = results[2][0][boxid]
classes.append(predclass)
if self.save_pred_images:
width = pilimg.size[0]
height = pilimg.size[1]
box = results[0][0][boxid]
xmin = int(box[1] * width)
ymin = int(box[0] * height)
xmax = int(box[3] * width)
ymax = int(box[2] * height)
draw = Draw(pilimg)
draw.rectangle([(xmin, ymin), (xmax, ymax)], outline='red')
draw.text((xmax + 5, ymin + 5),
"Class: " + str(self.class_map_str[predclass]),
font=self.font)
if self.save_pred_images:
pilimg.save(
"/capstone/ros/classifier_output/bag/{:0>5d}.jpg".format(
self.prediction_counter))
self.prediction_counter += 1
if classes:
keys = Counter(classes).keys()
vals = Counter(classes).values()
pred_class = keys[np.argmax(vals)]
return self.class_map[pred_class]
else:
return TrafficLight.UNKNOWN
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 __draw_sticker_text(cur_sticker: Sticker, location_text_offset,
author_text_offset, draw_context: ImageDraw.Draw):
draw_context.text(location_text_offset,
cur_sticker.location,
font=cur_sticker.font,
fill=cur_sticker.font_color,
draw_context=draw_context)
draw_context.text(author_text_offset,
cur_sticker.author,
font=cur_sticker.font,
fill=cur_sticker.font_color,
draw_context=draw_context)
def draw_text_centered(draw: ImageDraw.Draw, xy: Tuple[int, int], text: str,
face: FontList):
x, y = xy
for font in face:
width, _ = draw.textsize(text, font)
if width <= 150:
draw.text((x - width // 2, y - int(font.size / 1.7) + 1),
text,
font=font,
fill="black")
return
def fit(self, row_obj: dict, canvas: ImageDraw.Draw):
"""This function prints the text on image output.
"""
rows, font_properties = self.create_row_with_slash(row_obj=row_obj)
font, font_size = font_properties
color = 0 if row_obj.get('font_color') >= 255 / 2 else 255
x, y = row_obj.get('text_area')[0]
shift_y = 0
for row in rows:
if len(row) - 1 > 0 and row[0] == ' ':
row = row[1:]
canvas.text((x - 1, y + shift_y), row, fill=color, font=font)
shift_y += font_size + 5
def _draw_date_box(self, draw: ImageDraw.Draw, top_left_corner: Tuple[int, int], width: int, date: datetime) -> int:
"""
Draws a date/time clock onto the canvas at the given position.
Args:
draw: The ImageDraw instance to draw on the desired canvas.
top_left_corner: Where to start the box.
width: The fixed horizontal dimension of the box.
date: The date/time to display on the clock.
Returns:
The bottom y coordinate of the box, so that further elements may be drawn after it
"""
time_str = format_time(date, 'HH:mm', locale='pt_BR')
time_font = self.fonts['huge']
time_font_height = time_font.getsize('X')[1]
date_str = format_date(date, "EEEE\ndd 'de' MMM 'de' yyyy", locale='pt_BR').capitalize()
date_font = self.fonts['large']
date_font_height = date_font.getsize('X')[1]
margin = 20 * self.scaler_value
bottom_y = int(top_left_corner[1] + time_font_height + date_font_height * 2 + margin * 4)
draw.rectangle(
(
top_left_corner[0],
top_left_corner[1],
top_left_corner[0] + width,
bottom_y
),
fill=self.colors['date_box_background']
)
time_y = top_left_corner[1] + margin
draw.text(
(top_left_corner[0] + margin, time_y),
time_str,
fill=self.colors['date_box_text'],
font=time_font,
)
draw.multiline_text(
(top_left_corner[0] + margin, time_y + time_font_height + margin),
date_str,
fill=self.colors['date_box_text'],
font=date_font
)
return bottom_y
def generate_letter(char, font_size, font_name):
img_dim = (font_size + font_size / 2,) * 2
img = new_image("RGB", img_dim, (0, 0, 0))
img_draw = Draw(img)
#font = PIL.ImageFont.ImageFont()
#font.font = PIL.ImageFont.truetype(font_name, font_size)
#font.color = tuple( [randrange(126, 256) for i in range(3)] )
font = PIL.ImageFont.truetype(font_name, font_size)
color = tuple( [randrange(126, 256) for i in range(3)] )
img_draw.text((0, 0), char, color, font)
#img = img_draw.flush()
img = img.rotate(randrange(-30, 30), BICUBIC)
mask = new_image("L", img.size, 0)
mask.paste(img, (0, 0))
return img, mask
def draw(self,
icon: Icon,
size: Size = None,
color: Color = '#000000',
bg: Color = '#ffffff') -> PILImage:
icon = self._normalize(icon)
if size:
font = self.font.font_variant(size=max(size))
else:
font = self.font
size = (font.size, font.size)
image = Image.new('RGBA', size, color_to_rgb(bg))
draw = Draw(image) # type: ImageDraw
draw.text((0, 0), icon, fill=color_to_rgb(color), font=font)
return image
def DrawLapDuration(self, drw: ImageDraw.Draw):
height = 125
width = 225
top = self._resolution[1] - height
drw.rectangle(
((0, self._resolution[1] - height), (width, self._resolution[1])),
fill=(0, 0, 0, 255))
index = 0
text_height = 40
for lap_number, lap_duration_ms in self._lap_duration_queue[-3:]:
drw.text(
(0, top + (text_height * index)),
'%s %s' % (lap_number, _FormatLapDuration(lap_duration_ms)),
font=self._font,
fill=(0, 255, 0, 255))
index += 1
def draw_text_relative_to_point(
draw: ImageDraw.Draw,
x: float,
y: float,
text: str,
font: FreeTypeFont,
color: str,
axis=None,
):
text_width, text_heigth = draw.textsize(text, font)
if axis == "x":
position = (x - text_width / 2, y)
elif axis == "y":
position = (x, y - text_heigth / 2)
else:
position = (x - text_width / 2, y - text_heigth / 2)
draw.text(position, text, color, font=font)
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
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 plot_oriyolo(self, imgs, detections):
detections = non_max_suppression(detections, self.opt.conf_thres,
self.opt.nms_thres)
toImg = transforms.ToPILImage()
# we only show the image_batch[0]
idx = []
i = 0
cls_name = ['car', 'person', 'fire']
for detection in detections:
if detection is not None:
idx.append(i)
i += 1
if len(idx) == 0:
self.viz.text('no bbox found with the conf_thres in %.2f' %
(self.opt.conf_thres),
win=1)
return
for i in idx:
img = toImg(imgs[i, ...])
ori_w, ori_h = img.size
img = img.resize((270, 270))
detection = detections[i]
w, h = img.size
draw = Draw(img)
if detection is not None:
for x1, y1, x2, y2, conf, cls_conf, cls_pred in detection:
x1 = float(x1) / ori_w * w
y1 = float(y1) / ori_h * h
x2 = float(x2) / ori_w * w
y2 = float(y2) / ori_h * h
x1 = max(0, int(x1))
y1 = max(0, int(y1))
x2 = min(int(x2), w)
y2 = min(int(y2), h)
draw.rectangle([(x1, y1), (x2, y2)], outline=(255, 0, 0))
#print(cls_pred)
name = cls_name[int(cls_pred)]
name += "=%.4f" % float(cls_conf)
f = ImageFont.truetype("fonts-japanese-gothic.ttf", 15)
draw.text((x1, y1), name, 'blue', font=f)
self.viz.image(np.array(img).transpose((2, 0, 1)), win=i + 2)
def show_all(self, draw: ImageDraw.Draw, last_sample: Sample,
top_line: int) -> None:
gap = (self.height - top_line) // len(self.PROBES)
ypos = top_line
for index, value in enumerate(last_sample.values):
probe = self.PROBES[index]
draw.text(((0, ypos)),
probe.name,
fill=self.PROBES[index].colour,
font=self.fonts[0].heading)
valstr = self.value_str(probe, value)
size = draw.textlength(valstr, font=self.fonts[0].body)
xpos = self.width - size
draw.text(((xpos, ypos)),
valstr,
fill=self.PROBES[index].colour,
font=self.fonts[0].body)
ypos += gap
def antialiased_text(text: str,
font: ImageFont,
size_x: int,
size_y: int = None,
*,
offset_x: float = 1 / 2,
offset_y: float = 1 / 2,
wrap_width: int = 50,
msaa_size: int = 2,
**draw_kwargs) -> Image:
"""
Returns a new image with antialiased text that you can then paste on your source image.
Pillow has no support for antialiasing text so the way we achieve the same thing is
creating an image multiple times larger and then resizing it with the antialias filter.
:param text: The text to be written
:param font: The font to be used
:param size_x: The width of the desired image
:param size_y: The height of the desired image
:param offset_x: How far away from the top the text will be
:param offset_y: How far away from the left the text will be
:param draw_kwargs: Additional keyword arguments to the `draw` method
:param wrap_width: The length at which strings should be wrapped
:return: An image with the desired text
"""
if size_y is None:
size_y = size_x
font = truetype(font.path, size=font.size * msaa_size)
with Image.new('RGBA', (size_x * msaa_size, size_y * msaa_size)) as image:
draw = Draw(image)
for index, string in enumerate(textwrap.wrap(text, wrap_width),
start=-1):
width, height = font.getsize(string)
pos = (size_x * msaa_size - width) / offset_x**-1, (
size_y * msaa_size - height * -index) / offset_y**-1
draw.text(pos, string, font=font, **draw_kwargs)
return image.resize((size_x, size_y), resample=Image.ANTIALIAS)
def generate_capture(request):
"""
You can visit the view with GET params like k, b, f to custom the capture.
b indicates background color, and f foreground color.
The value of color should be an integer, which will be convert to a hex color value. That is to say the value
of a color should not be less than 0 or larger than 16777215.
k indicates the key of the capture. It should exist in session before this view is visited, otherwise A 404 error
will be throw out.
And once the view is visited, the answer of the capture will be set a key in session which k indicates.
"""
keyName, bcolor, fcolor = DEFAULT_CAPTURE_ID, DEFAULT_BACKGROUND, DEFAULT_FOREGROUND
if 'k' in request.GET:
if request.GET['k'] in request.session:
keyName = request.GET['k']
else:
raise Http404()
try:
if 'b' in request.GET:
bcolor = '#{:0>6.6s}'.format('%x' % max(min(int(request.GET['b']), 16777215), 0))
if 'f' in request.GET:
fcolor = '#{:0>6.6s}'.format('%x' % max(min(int(request.GET['f']), 16777215), 0))
except:
raise Http404()
ver_fun = snippets[randint(0, len(snippets) - 1)]
x, y = ver_fun[2](), ver_fun[3]()
request.session[keyName] = '%r' % ver_fun[1](x, y)
img = Image.new("RGB", (DEFAULT_WIDTH, DEFAULT_HEIGHT), bcolor)
draw = Draw(img)
font = ImageFont.truetype('font/SourceCodePro-Regular.ttf', DEFAULT_FONT_SIZE)
for i in xrange(0, 3):
draw.line([(0, randint(0, DEFAULT_HEIGHT)), (DEFAULT_WIDTH, randint(1, DEFAULT_HEIGHT))],
fill='#{:0>6.6s}'.format('%x' % randint(0, 16777215)))
if x < 0:
x = '(%s)' % x
if y < 0:
y = '(%s)' % y
text = ver_fun[0] % (x, y)
x, y = font.getsize(text)
draw.text((DEFAULT_WIDTH / 2 - x / 2, DEFAULT_HEIGHT / 2 - y / 2), text, font=font, fill=fcolor)
response = HttpResponse(mimetype='image/png')
img.save(response, 'PNG')
return response
def paint(self, draw: ImageDraw.Draw, regions: RegionMap) -> None:
sx, sy, ex, ey = self.region.poly.bounds
font_size = 30
factor = 0
tries = 0
while abs(factor - 1) > 0.05 and tries < 5:
font = self.font('/usr/share/fonts/truetype/ubuntu/Ubuntu-R.ttf',
font_size)
w, h = draw.textsize(self.region.text, font=font)
# TODO super random compromise betweeen fit to width and fit to height
factor = 0.7 * (ex - sx) / w + 0.3 * (ey - sy) / h
font_size = int(font_size * factor)
tries += 1
draw.text((sx, sy),
self.region.text,
fill=self.color,
font=font,
anchor="lt")
def load_chars(font_name, size, chars):
"""Load characters from given font of given size.
:param font_name: given font name
:param size: given size
:param chars: given set of characters
:return: dict of tuples - character: (image, max_match_val)
"""
font = truetype(font_name + ".ttf", size)
symbols = {}
for char in chars:
width, height = font.getsize(char)
img = new("1", (width, height), 0)
drawing = Draw(img)
drawing.text((0, 0), char, fill=255, font=font)
img = img.convert("L")
img = np.asarray(img, dtype=np.uint8)
if char != ' ':
img = crop_text(img)
symbols[char] = (img, match(img, img))
return symbols
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 draw_text_with_outline(self, draw: ImageDraw.Draw, text: str, x: float,
y: int, fnt: ImageFont.FreeTypeFont) -> None:
draw.text((x - 2, y - 2), text, (0, 0, 0), font=fnt)
draw.text((x + 2, y - 2), text, (0, 0, 0), font=fnt)
draw.text((x + 2, y + 2), text, (0, 0, 0), font=fnt)
draw.text((x - 2, y + 2), text, (0, 0, 0), font=fnt)
draw.text((x, y), text, (255, 255, 255), font=fnt)
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
icon_height = 0
# 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 + icon_width
# 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))
# das Icon muss auch rein, wenn wir eines haben
if icon:
alpha_channel = icon.split()[3]
mask = Image.eval(alpha_channel, lambda a: 255 if a >=128 else 0)
for offs in [0, height]:
button.paste(icon, (7, offs + int(height/2.0-icon_height/2.0)), mask)
# dann die Beschriftung reinmalen
draw = Draw(button)
draw.text((icon_width + args.padding, upper_text), label, font=font, fill=args.text_color)
draw.text((icon_width + args.padding, lower_text), label, font=font, fill=args.text_color)
# und schliesslich nur noch den Button speichern
#button.show()
button.save(filename, 'PNG')
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)
# und schliesslich nur noch den Button speichern
#button.show()
button.save(filename, 'PNG')
