def draw(self, pil_draw: ImageDraw, **kwargs) -> None:
"""
:arg
pil_draw: PIL Draw object
"""
pil_draw.rectangle([self.x_min, self.y_min, self.x_max, self.y_max],
**kwargs)
def draw_cell(square: Square, draw: ImageDraw, color: tuple):
border = (
square.top_left_x,
square.top_left_y,
square.top_left_x + square.size,
square.top_left_y + square.size)
draw.rectangle(border, color)
def draw(self, draw: ImageDraw):
pen, brush = self._get_pen_brush()
if hasattr(self, 'de') and self.de > 0:
brush_s1 = aggdraw.Brush(fade_color(self.fill, self.shade))
brush_s2 = aggdraw.Brush(fade_color(self.fill, 2 * self.shade))
draw.line([
self.x1 + self.de, self.y1 - self.de, self.x1 + self.de,
self.y2 - self.de
], pen)
draw.line([self.x1 + self.de, self.y2 - self.de, self.x1, self.y2],
pen)
draw.line([
self.x1 + self.de, self.y2 - self.de, self.x2 + self.de,
self.y2 - self.de
], pen)
draw.polygon([
self.x1, self.y1, self.x1 + self.de, self.y1 - self.de,
self.x2 + self.de, self.y1 - self.de, self.x2, self.y1
], pen, brush_s1)
draw.polygon([
self.x2 + self.de, self.y1 - self.de, self.x2, self.y1,
self.x2, self.y2, self.x2 + self.de, self.y2 - self.de
], pen, brush_s2)
draw.rectangle([self.x1, self.y1, self.x2, self.y2], pen, brush)
def _draw_cs(self, dr_: ImageDraw, cs: CargoSpace, cord_x: int,
cord_y: int, font: ImageFont, col_w: list, we_grp: tuple):
reset_x = cord_x
cs_sum_we = sum(col_w)
for f in range(0, self._dataset.width, 1):
dr_.text((cord_x + 12, cord_y + 43),
'%s%%' % _calc_we_dist(cs_sum_we, col_w[f]),
fill='black')
cord_x += 40
cord_x = reset_x
for y in range(0, self._dataset.width, 1):
for x in range(0, self._dataset.height, 1):
curr_pack = cs.columns[x].get(y)
if curr_pack is not None:
rgb = 240 - (25 * np.digitize(curr_pack.weight, we_grp))
dr_.rectangle(
((cord_x, cord_y), (cord_x + 35, cord_y + 35)),
fill=(rgb, rgb, rgb),
outline='black')
dr_.text((cord_x + 5, cord_y + 5),
'ID: %s' % curr_pack.id,
fill='black',
font=font)
dr_.text((cord_x + 5, cord_y + 20),
'WE: %s' % curr_pack.weight,
fill='black',
font=font)
cord_x += 40
cord_y -= 40
cord_x = reset_x
def draw(self, draw: ImageDraw) -> None:
if self._draw_border:
draw.rectangle(
(self.abs_col, self.abs_row, self.abs_col + self.width - 1,
self.abs_row + self.height - 1),
outline=self.foreground,
fill=self.background)
def __dessiner_entete_nom_mois(self, origine: Point, crayon: ImageDraw):
"""
Dessine l'en-tête du mois
:param origine: le point d'insértion de l'en-tête
:param crayon: l'outil de dessin
:param couleur_titre: la couleur du texte du nom de mois
"""
crayon.rectangle(
(origine.to_tuple(), origine.deplacer(
self.taille_entete_nom).to_tuple()),
fill=self.couleur_fond_entete.value)
if self.inclure_annee:
annee_str = str(self.donnees.annee)
taille_annee_mois = calculer_taille_texte(
annee_str, police=CONST.POLICE_ANNEE_ENTETE_MOIS)
pt_ins_annee_mois = (origine.x + self.taille_entete_nom.longueur -
taille_annee_mois.longueur, origine.y)
crayon.text(pt_ins_annee_mois,
annee_str,
fill=self.couleur_titre.value,
font=CONST.POLICE_ANNEE_ENTETE_MOIS)
# création d’un objet 'dessin' qui permet de dessiner sur l’image
dessiner_texte(crayon, self.nom_mois, CONST.POLICE_NOM_MOIS,
self.taille_entete_nom, origine, self.couleur_titre,
AlignementHorizontal.CENTRE)
def draw_text(draw: ImageDraw, image: Image, font, text="Text example", gravity="South", fill=(0, 0, 0), padding=5, margin=10):
text_width, text_height = draw.textsize(text, font=font)
gravity = gravity.lower()
if gravity == 'south':
x = (image.width - text_width) // 2
y = image.height - text_height - margin - padding
elif gravity == 'north':
x = (image.width - text_width) // 2
y = margin + padding
elif gravity == 'center':
x = (image.width - text_width) // 2
y = (image.height - text_height) // 2
elif gravity == 'southwest':
x = margin + padding
y = image.height - text_height - margin - padding
elif gravity == 'southeast':
x = image.width - margin - padding - text_width
y = image.height - text_height - margin - padding
elif gravity == 'northwest':
x = y = margin + padding
elif gravity == 'northeast':
x = image.width - margin - padding - text_width
y = margin + padding
else:
x = y = 0
draw.rectangle((x - padding, y - padding, x + text_width + padding, y + text_height + padding), fill=fill)
draw.text((x, y), text=text, font=font)
def draw_hollow_rect(draw: ImageDraw, rect: Tuple[int, int, int, int],
color: Tuple[int, int, int],
thickness: int = 2) -> None:
"""
Fills a rectanglular area with a given color, but erases the inside,
leaving an outline with a completely transparent inside.
Parameters
----------
draw: ImageDraw
The drawing handler.
rect: Tuple[int, int, int, int]
The bounds of the rectangle. The bounds are in the format
(x1, y1, x2, y2), where the points define the edge coordinates.
The second point lies outside of the rectangle bounds.
color
The color of the rectangle.
thickness: int
How thick to make the line in pixels. Defaults to 2.
"""
draw.rectangle(rect, fill=color)
rect = (rect[0] + 2, rect[1] + 2, rect[2] - 2, rect[3] - 2)
draw.rectangle(rect, fill=(0, 0, 0, 0))
def draw_activity(self, draw: ImageDraw, name: str, time: str,
progress: float, x: int, y: int):
title_font_size = 40
text_progress_margin = 25
progress_end_y = y + BasicImageCreator.PROGRESS_BAR_HEIGHT + text_progress_margin
progress_start_xy = (x, y + text_progress_margin)
background_end_xy = (x + BasicImageCreator.PROGRESS_BAR_WIDTH,
progress_end_y)
foreground_end_xy = (x +
BasicImageCreator.PROGRESS_BAR_WIDTH * progress,
progress_end_y)
draw.rectangle(
(progress_start_xy, background_end_xy),
fill=self.data_repository.get_setting("progress_background_color"))
draw.rectangle(
(progress_start_xy, foreground_end_xy),
fill=self.data_repository.get_setting("progress_foreground_color"))
# Draw activity title
draw.text(
(x, y - title_font_size),
name,
font=ImageFont.truetype(self.get_font("semi_bold"),
title_font_size),
fill=self.data_repository.get_setting("activity_title_color"))
# Draw activity time
draw.text((x + BasicImageCreator.PROGRESS_BAR_WIDTH, y - 20),
BasicImageCreator.time_as_str(time),
font=ImageFont.truetype(self.get_font("bold"), 30),
fill=self.data_repository.get_setting("activity_time_color"),
anchor="rt")
def render_text(self, _: Image, draw: ImageDraw, draw_property: Mapping,
bounding_box: Tuple[Tuple[int, int], Tuple[int, int]], current_x: int, current_y: int,
backwards: bool) -> Tuple[int, int]:
font = ImageFont.truetype(draw_property["font"], draw_property["font_size"])
text = self.properties.get(draw_property["property"])
current_x, current_y = self.resolve_position(draw_property["position"], bounding_box, current_x, current_y)
if text is not None:
background = self.properties.get(draw_property["background_property"])
if background is None:
background = draw_property["background_default"]
text_color = self.properties.get(draw_property["text_color_property"])
if text_color is None:
text_color = draw_property["text_color_default"]
text_width, text_height = draw.textsize(text, font)
desired_width = draw_property["size"][0] if draw_property["size"][0] != "auto" else text_width
desired_height = draw_property["size"][1] if draw_property["size"][1] != "auto" else text_height
if backwards:
current_x -= desired_width
draw.rectangle(((current_x, current_y), (current_x + desired_width, current_y + desired_height)),
fill=background)
# CodeReview: center between current_y and bottom of bounding box
x_coord = (current_x + (desired_width - text_width) // 2) if draw_property["centered_width"] else current_x
y_coord = (current_y + (desired_height - text_height) // 2) if draw_property["centered_height"] \
else current_y
draw.text((x_coord, y_coord), text, fill=text_color, font=font)
current_x += desired_width
elif draw_property["required"]:
raise Exception(f"Missing required property: {draw_property['property']} from card {self.properties}")
return current_x, current_y
def draw(self, draw: ImageDraw):
x0 = self.x - self.size / 2
y0 = self.y - self.size / 2
x1 = self.x + self.size / 2
y1 = self.y + self.size / 2
draw.rectangle([x0, y0, x1, y1], self.color)
def render_layer(self, dungeon: Dungeon,
paintableRooms: Dict[DungeonRoom, PaintableRoom],
img: Image, draw: ImageDraw) -> None:
"""See RenderLayer for docs."""
rect = (0, 0, img.size[0], img.size[1])
draw.rectangle(rect, fill=self.color)
def rounded_rectangle(draw: ImageDraw, xy, r, fill=None, outline=None):
draw.rectangle([(xy[0][0], xy[0][1] + r), (xy[1][0], xy[1][1] - r)],
fill=fill,
outline=outline)
draw.rectangle([(xy[0][0] + r, xy[0][1]), (xy[1][0] - r, xy[1][1])],
fill=fill,
outline=outline)
draw.pieslice([xy[0], (xy[0][0] + r * 2, xy[0][1] + r * 2)],
180,
270,
fill=fill,
outline=outline)
draw.pieslice([(xy[1][0] - r * 2, xy[1][1] - r * 2), xy[1]],
0,
90,
fill=fill,
outline=outline)
draw.pieslice([(xy[0][0], xy[1][1] - r * 2), (xy[0][0] + r * 2, xy[1][1])],
90,
180,
fill=fill,
outline=outline)
draw.pieslice([(xy[1][0] - r * 2, xy[0][1]), (xy[1][0], xy[0][1] + r * 2)],
270,
360,
fill=fill,
outline=outline)
def _render_outer_rect(self, draw: ImageDraw, x1: int, y1: int,
y2: int) -> None:
x3 = x1
y3 = y1 + int(self.corner_radius * self.upper_outer_radius_y)
x4 = x1 + int(self.corner_radius * max(self.upper_outer_radius_x,
self.lower_outer_radius_x))
y4 = y2 - int(self.corner_radius * self.lower_outer_radius_y)
draw.rectangle(((x3, y3), (x4, y4)), fill=1)
def _render_lower_rect(self, draw: ImageDraw, x1: int, x2: int,
y2: int) -> None:
x3 = x1 + int(self.corner_radius * self.lower_outer_radius_x)
y3 = y2 - int(self.corner_radius * max(self.lower_outer_radius_y,
self.lower_inner_radius_y))
x4 = x2 - int(self.corner_radius * self.lower_inner_radius_x)
y4 = y2
draw.rectangle(((x3, y3), (x4, y4)), fill=1)
def render_candlestick(ohlc: Tuple[float, ...], x: int,
y_transformer: Callable[[float], int], draw: ImageDraw):
color = (255, 55, 55, 255) if ohlc[3] < ohlc[0] else (55, 255, 55, 255)
draw.rectangle((x, y_transformer(max(
ohlc[0], ohlc[3])), x + 2, y_transformer(min(ohlc[0], ohlc[3]))),
fill=color)
draw.line((x + 1, y_transformer(ohlc[1]), x + 1, y_transformer(ohlc[2])),
fill=color)
def draw(self, draw: ImageDraw, scale: float):
half_width, half_height = self.width / 2, self.height / 2
x1, y1 = self.x - half_width, self.y - half_height
x2, y2 = self.x + half_width, self.y + half_height
xy = x1 * scale, y1 * scale, x2 * scale, y2 * scale
fill = self.fill if self.children > 0 else (211, 211, 211)
draw.rectangle(xy, fill=fill, outline=self.outline)
return
def _draw_punch(draw: ImageDraw, col_start, row_start):
punch_height = 19
punch_width = 10
punch_color = (0, 0, 0)
col_end = col_start + punch_width
row_end = row_start + punch_height
draw.rectangle([col_start, row_start, col_end, row_end], fill=punch_color)
def render_layer(self, dungeon: Dungeon,
paintableRooms: Dict[DungeonRoom, PaintableRoom],
img: Image, draw: ImageDraw) -> None:
"""See RenderLayer for docs."""
for room in dungeon.rooms:
rect = paintableRooms[room].rect
col = self.get_gradient_color(room.difficulty)
draw.rectangle(rect, fill=col)
def render_candlestick(ohlc: Tuple[float, ...], x: int,
y_transformer: Callable[[float], int], draw: ImageDraw):
#empty rectangle to represent negative candle sticks
fill_rectangle = 0 if ohlc[3] < ohlc[0] else 1
draw.line((x + 1, y_transformer(ohlc[1]), x + 1, y_transformer(ohlc[2])),
fill=1)
draw.rectangle((x, y_transformer(max(
ohlc[0], ohlc[3])), x + 2, y_transformer(min(ohlc[0], ohlc[3]))),
fill=fill_rectangle,
outline=1)
def _draw_selections(self, draw: ImageDraw) -> None:
y = 2 + self._display.character_height
for i, v in enumerate(self._selections):
# only show items that fit
if y < (self._display.height - self._display.character_height * 3):
# has room still
if self._selected == i:
draw.rectangle([(0, y), (self._display.width, y + self._display.character_height)], fill=(255, 0, 0))
draw.text((1, y), v.title, fill=(255, 255, 255))
y += self._display.character_height
def _render_center_rect(self, draw: ImageDraw, x1: int, y1: int, x2: int,
y2: int) -> None:
x3 = x1 + int(self.corner_radius * max(self.upper_outer_radius_x,
self.lower_outer_radius_x)) - 2
y3 = y1 + int(self.corner_radius * max(self.upper_outer_radius_y,
self.upper_inner_radius_y)) - 1
x4 = x2 - int(self.corner_radius * max(self.upper_inner_radius_y,
self.lower_inner_radius_y)) + 2
y4 = y2 - int(self.corner_radius * max(self.lower_outer_radius_y,
self.lower_inner_radius_y)) + 1
draw.rectangle(((x3, y3), (x4, y4)), fill=1)
def _rect(self,
draw: ImageDraw,
x: int,
y: int,
w: int,
h: int,
color: str = None):
m = self.multiplier
if color is None:
color = self.theme.details
draw.rectangle([x * m, y * m, (x + w) * m - 1, (y + h) * m - 1], color)
def _render_rect(self, draw: ImageDraw,
rect: Tuple[float, float, float, float],
fill: Optional[str],
outline: str,
**kwargs):
bb = BoundingBox(rect)
for bb in bb.partition_x(self.width, self.row_height):
(w, h) = self.image.size
r = (bb.bb[0], bb.bb[1], min(w - 1, bb.bb[2]), min(h - 1, bb.bb[3]))
draw.rectangle(r, fill=fill, outline=outline, **kwargs)
def draw_rectangle(draw_context: ImageDraw,
box_coordinates: np.array,
color="red",
width=3):
x1, y1, x2, y2 = box_coordinates
offset = 1
for i in range(0, width):
draw_context.rectangle(((x1, y1), (x2, y2)), outline=color)
x1 = x1 - offset
y1 = y1 + offset
x2 = x2 + offset
y2 = y2 - offset
def draw_rectangle(self, draw: ImageDraw, percent: float, font: ImageFont):
left_x = self.width / 6
left_y = self.height * 15 / 24
right_x = self.width * 4 / 6
right_y = left_y + self.height * 0.08
draw.rectangle(((left_x, left_y), (right_x, right_y)),
outline=(255, 0, 0),
width=5)
draw.rectangle(((left_x, left_y), (right_x * percent / 100, right_y)),
fill=(255, 0, 0))
draw.text((right_x + self.width * 0.03, left_y + self.height * 0.02),
f'{percent:2.2f}%', (255, 0, 0),
font=font)
def rounded_rectangle(
draw: ImageDraw, box: Tuple[int, int, int, int],
radius: int,
fill: Any = None,
outline: Any = None) -> None:
"""Draw a rounded rectangle on the given image."""
x1, y1, x2, y2 = box
draw.rectangle(
(x1 + radius, y1, x2 - radius, y2),
fill=fill,
outline=outline
)
draw.rectangle(
(x1, y1 + radius, x2, y2 - radius),
fill=fill,
outline=outline
)
diameter = radius * 2
draw.pieslice(
(x1, y1, x1 + diameter, y1 + diameter),
start=180,
end=270,
fill=fill,
outline=outline
)
draw.pieslice(
(x2 - diameter, y1, x2, y1 + diameter),
start=270,
end=360,
fill=fill,
outline=outline
)
draw.pieslice(
(x2 - diameter, y2 - diameter, x2, y2),
start=0,
end=90,
fill=fill,
outline=outline
)
draw.pieslice(
(x1, y2 - diameter, x1 + diameter, y2),
start=90,
end=180,
fill=fill,
outline=outline
)
def render_layer(self, dungeon: Dungeon,
paintableRooms: Dict[DungeonRoom, PaintableRoom],
img: Image, draw: ImageDraw) -> None:
"""See RenderLayer for docs."""
regionColors = [(0, 0, 0)] * dungeon.region_count()
for i in range(len(regionColors)):
r = rand(128) + 128
g = rand(128) + 128
b = rand(128) + 128
regionColors[i] = (r, g, b)
for room in dungeon.rooms:
rect = paintableRooms[room].rect
draw.rectangle(rect, fill=regionColors[room.region])
def draw(self, active_index: float, canvas: ImageDraw):
"""Draw the menu into a canvas.
`active_index` can be a float for smooth transitions
"""
# copy the relevant part of the pre-rendered menu
y_start = self._y_offset + \
self._lineToEntryIndex(active_index, 0) * self._line_h
rect = (0, y_start, self._line_w,
y_start + self._num_rows * self._line_h)
visible = self._full_menu.crop(rect)
canvas.bitmap((0, 0), visible, fill="white")
# then draw the active menu frame
n = active_index % self._num_rows
canvas.rectangle((0, int(n * self._line_h), self._line_w - 1,
int((n + 1) * self._line_h - 1)),
outline="white")
def draw_rectangle(draw: ImageDraw, position: int, width: int, tier: str):
"""
Draws a rectangle over the image given a ImageDraw object and the intended
position, width, and tier.
:param draw: an picture we're editing
:param position: the position of the rectangle to be added
:param width: the width of the rectangle to be added
:param tier: the tier which determines the outline
:return: nothing
"""
draw.rectangle(((IMAGE_WIDTH - width - X_OFFSET * 2, position),
(IMAGE_WIDTH, position + RECTANGLE_HEIGHT)),
fill=RECTANGLE_FILL,
outline=TIER_MAP.get(tier.lower(), None),
width=7)
def drawpixel(target: ImageDraw, x, y, size, color):
target.rectangle((x * size, y * size, (x + 1) * size, (y + 1) * size), fill=color)
