914 lines
73 KiB
Plaintext
914 lines
73 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import requests\n",
|
|
"from io import BytesIO\n",
|
|
"\n",
|
|
"def load_image_from_url(url=None):\n",
|
|
" if(url is None):\n",
|
|
" # URL de la imagen en línea\n",
|
|
" url = \"https://img.freepik.com/iconos-gratis/autobus_318-574563.jpg\"\n",
|
|
"\n",
|
|
" # Descarga la imagen desde la URL\n",
|
|
" response = requests.get(url)\n",
|
|
" image_data = response.content\n",
|
|
" # Crea un objeto Image desde los datos descargados\n",
|
|
" image = Image.open(BytesIO(image_data))\n",
|
|
" return image\n",
|
|
"\n",
|
|
"def crop_image(image):\n",
|
|
" # Corta 150 píxeles de la parte superior e inferior\n",
|
|
" top_cut = 165\n",
|
|
" bottom_cut = 165\n",
|
|
" width, height = image.size\n",
|
|
" cropped_image = image.crop((0, top_cut, width, height - bottom_cut))\n",
|
|
" return cropped_image\n",
|
|
"\n",
|
|
"def resize_image(image, target_width=None, target_height=None):\n",
|
|
" \"\"\"\n",
|
|
" Ajusta el tamaño de la imagen mientras mantiene las proporciones.\n",
|
|
" \n",
|
|
" Args:\n",
|
|
" image (PIL.Image.Image): La imagen a redimensionar.\n",
|
|
" target_width (int, opcional): El ancho objetivo deseado.\n",
|
|
" target_height (int, opcional): La altura objetivo deseada.\n",
|
|
" \n",
|
|
" Returns:\n",
|
|
" PIL.Image.Image: La imagen redimensionada.\n",
|
|
" \"\"\"\n",
|
|
" width, height = image.size\n",
|
|
" aspect_ratio = width / height\n",
|
|
" \n",
|
|
" if target_width is None and target_height is None:\n",
|
|
" raise ValueError(\"Debes proporcionar al menos una de las dimensiones objetivo.\")\n",
|
|
" \n",
|
|
" if target_width is not None and target_height is None:\n",
|
|
" new_width = target_width\n",
|
|
" new_height = int(target_width / aspect_ratio)\n",
|
|
" elif target_width is None and target_height is not None:\n",
|
|
" new_width = int(target_height * aspect_ratio)\n",
|
|
" new_height = target_height\n",
|
|
" else:\n",
|
|
" new_width = target_width\n",
|
|
" new_height = target_height\n",
|
|
" \n",
|
|
" resized_image = image.resize((new_width, new_height))\n",
|
|
" return resized_image\n",
|
|
"\n",
|
|
"def load_draw_image():\n",
|
|
" image = load_image_from_url()\n",
|
|
" image = crop_image(image)\n",
|
|
" image = resize_image(image, target_height=25)\n",
|
|
" return image"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"from PIL import ImageDraw, ImageFont\n",
|
|
"\n",
|
|
"def draw_rounded_rectangle_with_text(draw, position, width, height, text, font=None, fontsize=16, border_color=(0, 0, 0), background_color=(255, 255, 255), text_color=(0, 0, 0)):\n",
|
|
" \"\"\"\n",
|
|
" Dibuja un rectángulo con bordes redondeados y un texto encima en un objeto ImageDraw.\n",
|
|
"\n",
|
|
" Args:\n",
|
|
" draw (PIL.ImageDraw.ImageDraw): El objeto ImageDraw en el que se dibujará.\n",
|
|
" position (tuple): Las coordenadas (x, y) de la esquina superior izquierda del rectángulo.\n",
|
|
" width (int): El ancho del rectángulo.\n",
|
|
" height (int): La altura del rectángulo.\n",
|
|
" text (str): El texto a dibujar encima del rectángulo.\n",
|
|
" font (PIL.ImageFont.ImageFont, opcional): La fuente a utilizar para el texto.\n",
|
|
" border_color (tuple, opcional): El color del borde del rectángulo en formato RGB.\n",
|
|
" background_color (tuple, opcional): El color de fondo del rectángulo en formato RGB.\n",
|
|
" text_color (tuple, opcional): El color del texto en formato RGB.\n",
|
|
" \"\"\"\n",
|
|
" corner_radius = 10\n",
|
|
" border_width = 2\n",
|
|
" \n",
|
|
" x, y = position\n",
|
|
" x2, y2 = x + width, y + height\n",
|
|
" \n",
|
|
" draw.rounded_rectangle(\n",
|
|
" [(x + border_width, y + border_width), (x2 - border_width, y2 - border_width)],\n",
|
|
" corner_radius,\n",
|
|
" outline=border_color,\n",
|
|
" width=border_width,\n",
|
|
" fill=background_color\n",
|
|
" )\n",
|
|
" \n",
|
|
" text_position = ((x + x2) // 2, (y + y2) // 2)\n",
|
|
" \n",
|
|
" if font is None:\n",
|
|
" font = ImageFont.load_default()\n",
|
|
" \n",
|
|
" # text_size = font.getsize()\n",
|
|
" # text_size = draw.textsize(text, font)\n",
|
|
"\n",
|
|
" txt_img = Image.new(\"RGBA\", (width, height), (255,255,255,0))\n",
|
|
" # font = ImageFont.truetype(font, fontsize)\n",
|
|
" d = ImageDraw.Draw(txt_img)\n",
|
|
" text_size = d.textsize(text, font=font)\n",
|
|
"\n",
|
|
" text_position = (text_position[0] - text_size[0] // 2, text_position[1] - text_size[1] // 2)\n",
|
|
" \n",
|
|
" draw.text(text_position, text, fill=text_color, font=font)\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"from PIL import Image, ImageDraw, ImageFont\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"import numpy as np\n",
|
|
"\n",
|
|
"# Crear una imagen en blanco con el tamaño especificado\n",
|
|
"width, height = 160, 80\n",
|
|
"background_color = (0, 0, 128) # Azul marino\n",
|
|
"border_color = (0, 0, 0) # Negro\n",
|
|
"text_color = (255, 255, 255) # Blanco\n",
|
|
"corner_radius = 5\n",
|
|
"\n",
|
|
"image = Image.new(\"RGB\", (width, height), text_color)\n",
|
|
"draw = ImageDraw.Draw(image)\n",
|
|
"\n",
|
|
"# Definir la información\n",
|
|
"linea_bus = \"16 I\"\n",
|
|
"\n",
|
|
"def load_barlow(font_size=12):\n",
|
|
" # Ruta a la fuente TTF personalizada\n",
|
|
" font_path = \"/app/data/Barlow-Medium.ttf\"\n",
|
|
" # Carga la fuente\n",
|
|
" return ImageFont.truetype(font_path, font_size)\n",
|
|
"\n",
|
|
"font = load_barlow()\n",
|
|
"# font = ImageFont.load_default()\n",
|
|
"\n",
|
|
"# Dibujar el recuadro con esquinas redondeadas\n",
|
|
"border_width = 1\n",
|
|
"rect_width = 30\n",
|
|
"rect_width -= border_width\n",
|
|
"rect_height = 30\n",
|
|
"rect_height -= border_width\n",
|
|
"\n",
|
|
"draw.rounded_rectangle(\n",
|
|
" [(border_width, border_width), (rect_width - border_width, rect_height - border_width)],\n",
|
|
" corner_radius,\n",
|
|
" outline=border_color,\n",
|
|
" width=border_width,\n",
|
|
" fill=background_color\n",
|
|
")\n",
|
|
"w, h = draw.im.size\n",
|
|
"# Dibujar la placa patente en el centro\n",
|
|
"text_width, text_height = draw.im.size\n",
|
|
"# .textsize(linea_bus, font=font)\n",
|
|
"text_position = (0.15*rect_width, 0.2*rect_height)\n",
|
|
"\n",
|
|
"draw.text(text_position, linea_bus, fill=text_color, font=font)\n",
|
|
"\n",
|
|
"# Poner el tiempo estimado de espera\n",
|
|
"text_position = (0.5*rect_width, 0.25*rect_height)\n",
|
|
"draw.text(text_position, linea_bus, fill=text_color, font=font)\n",
|
|
"\n",
|
|
"# # Llamar a la función para dibujar un rectángulo con texto encima\n",
|
|
"# draw_rounded_rectangle_with_text(draw, (50, 50), 300, 100, \"Texto de Prueba\")\n",
|
|
"\n",
|
|
"# Supongamos que tienes una función llamada load_draw_image() que devuelve la imagen que quieres agregar\n",
|
|
"loaded_image = load_draw_image()\n",
|
|
"\n",
|
|
"# Crear una imagen en blanco del mismo tamaño que loaded_image con fondo blanco\n",
|
|
"white_background = Image.new(\"RGB\", loaded_image.size, (255, 255, 255))\n",
|
|
"\n",
|
|
"# Pega la loaded_image en la imagen en blanco\n",
|
|
"white_background.paste(loaded_image, (0, 0), loaded_image)\n",
|
|
"\n",
|
|
"# Calcula la posición para agregar la imagen cargada\n",
|
|
"image_position = (0, 50) # Cambia esto según tu diseño\n",
|
|
"\n",
|
|
"# Agrega la imagen a la imagen creada\n",
|
|
"image.paste(white_background, image_position)\n",
|
|
"\n",
|
|
"# Convertir la imagen de PIL a un array de numpy para matplotlib\n",
|
|
"image_array = np.array(image)\n",
|
|
"\n",
|
|
"# Mostrar la imagen utilizando matplotlib\n",
|
|
"plt.imshow(image_array)\n",
|
|
"plt.axis(\"off\") # Ocultar ejes\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"from PIL import Image, ImageDraw\n",
|
|
"\n",
|
|
"def cartel_micro(h, w):\n",
|
|
" image = Image.new(\"RGB\", (w, h), \"white\")\n",
|
|
" proportion = 0.4\n",
|
|
" width_border = 1\n",
|
|
" draw = ImageDraw.Draw(image)\n",
|
|
"\n",
|
|
" # Draw a rounded rectangle\n",
|
|
" draw.rounded_rectangle((0, 0, w-width_border, h-width_border), fill=\"blue\", outline=\"black\",\n",
|
|
" width=width_border, radius=5)\n",
|
|
" draw.rounded_rectangle((0, 0, proportion*w-width_border, h-width_border), fill=\"yellow\", outline=\"black\",\n",
|
|
" width=width_border, radius=5)\n",
|
|
" return image\n",
|
|
" \n",
|
|
" \n",
|
|
"if __name__ == \"__main__\":\n",
|
|
" plt.imshow(cartel_micro(30, 60))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"(0, 6, 18, 20)\n",
|
|
"17.5\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"def load_barlow(font_size=12):\n",
|
|
" # Ruta a la fuente TTF personalizada\n",
|
|
" font_path = \"/app/data/Barlow-Medium.ttf\"\n",
|
|
" # Carga la fuente\n",
|
|
" return ImageFont.truetype(font_path, font_size)\n",
|
|
"\n",
|
|
"def number_letter_bus(h, w):\n",
|
|
" image = Image.new(\"RGB\", (w, h), \"white\")\n",
|
|
" linea_bus = \"16\"\n",
|
|
" text_color = 'black'\n",
|
|
" font = load_barlow(font_size=20)\n",
|
|
" font_width = font.getlength(linea_bus)\n",
|
|
" print(font.getbbox(linea_bus))\n",
|
|
" print(font_width)\n",
|
|
" font_width = np.round(font_width)\n",
|
|
" offset_width = np.round(w/2)\n",
|
|
" #- np.round(font_width/2)\n",
|
|
" text_position = (offset_width, 0)\n",
|
|
"\n",
|
|
" draw = ImageDraw.Draw(image)\n",
|
|
" draw.text(\n",
|
|
" #text_position,\n",
|
|
" (0,0),\n",
|
|
" linea_bus,\n",
|
|
" fill=text_color,\n",
|
|
" font=font,\n",
|
|
" align =\"center\"\n",
|
|
" )\n",
|
|
" return image\n",
|
|
"\n",
|
|
"if __name__ == \"__main__\":\n",
|
|
" plt.imshow(number_letter_bus(30, 60))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 39,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class MyDraw():\n",
|
|
" def __init__(self, height, width):\n",
|
|
" self.height = height\n",
|
|
" self.width = width\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def save_image(self, filename):\n",
|
|
" self.image.save(filename)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def start_draw(self, background_color=None):\n",
|
|
" if background_color is None:\n",
|
|
" background_color = self.theme_params['background_color']\n",
|
|
"\n",
|
|
" self.image = Image.new(\"RGB\", (self.width, self.height), background_color)\n",
|
|
" self.draw = ImageDraw.Draw(self.image)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def add_image(self, obj, position):\n",
|
|
" image_to_add = obj.get_image() # Obtiene la imagen del objeto pasado como argumento\n",
|
|
" if image_to_add:\n",
|
|
" self.image.paste(image_to_add, position)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def get_draw(self):\n",
|
|
" return self.draw\n",
|
|
" \n",
|
|
" def get_image(self):\n",
|
|
" return self.image\n",
|
|
"\n",
|
|
" def set_params(self,params):\n",
|
|
" self.prms = params\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_theme(self,mode='day'):\n",
|
|
" if(mode=='day'):\n",
|
|
" self.start_day_mode()\n",
|
|
" else:\n",
|
|
" self.start_night_mode()\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def start_day_mode(self):\n",
|
|
" self.theme_params = {\n",
|
|
" 'background_color': 'white',\n",
|
|
" 'text_color': 'black',\n",
|
|
" 'poster_line_color': 'black',\n",
|
|
" }\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def start_night_mode(self):\n",
|
|
" self.theme_params = {\n",
|
|
" 'background_color': 'black',\n",
|
|
" 'text_color': 'white',\n",
|
|
" 'poster_line_color': 'gray',\n",
|
|
" }\n",
|
|
" pass\n",
|
|
" \n",
|
|
" def load_barlow(self, font_size=None):\n",
|
|
" # Ruta a la fuente TTF personalizada\n",
|
|
" font_path = \"/app/data/Barlow-Medium.ttf\"\n",
|
|
" # Carga la fuente\n",
|
|
" if font_size is None:\n",
|
|
" self.font = ImageFont.truetype(font_path, self.prms['font_size'])\n",
|
|
" else:\n",
|
|
" self.font = ImageFont.truetype(font_path, font_size)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def preview(self):\n",
|
|
" plt.imshow(self.image)\n",
|
|
" plt.axis('off')\n",
|
|
" plt.show()\n",
|
|
"\n",
|
|
" def crop_image(self, top_cut, bottom_cut):\n",
|
|
" width, height = self.image.size\n",
|
|
" self.image = self.image.crop((0, top_cut, width, height - bottom_cut))\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def resize_image(self, target_width=None, target_height=None):\n",
|
|
" \"\"\"\n",
|
|
" Ajusta el tamaño de la imagen mientras mantiene las proporciones.\n",
|
|
" \n",
|
|
" Args:\n",
|
|
" image (PIL.Image.Image): La imagen a redimensionar.\n",
|
|
" target_width (int, opcional): El ancho objetivo deseado.\n",
|
|
" target_height (int, opcional): La altura objetivo deseada.\n",
|
|
" \n",
|
|
" Returns:\n",
|
|
" PIL.Image.Image: La imagen redimensionada.\n",
|
|
" \"\"\"\n",
|
|
" width, height = self.image.size\n",
|
|
" aspect_ratio = width / height\n",
|
|
" \n",
|
|
" if target_width is None and target_height is None:\n",
|
|
" raise ValueError(\"Debes proporcionar al menos una de las dimensiones objetivo.\")\n",
|
|
" \n",
|
|
" if target_width is not None and target_height is None:\n",
|
|
" new_width = target_width\n",
|
|
" new_height = int(target_width / aspect_ratio)\n",
|
|
" elif target_width is None and target_height is not None:\n",
|
|
" new_width = int(target_height * aspect_ratio)\n",
|
|
" new_height = target_height\n",
|
|
" else:\n",
|
|
" new_width = target_width\n",
|
|
" new_height = target_height\n",
|
|
" \n",
|
|
" self.image = self.image.resize((new_width, new_height))\n",
|
|
" pass\n",
|
|
" \n",
|
|
"class BusPoster(MyDraw):\n",
|
|
"\n",
|
|
" def start_draw(self):\n",
|
|
" return super().start_draw()\n",
|
|
"\n",
|
|
" def set_colors(self):\n",
|
|
" width_border = self.prms['width_border']\n",
|
|
" proportion = self.prms['proportion']\n",
|
|
" fill_color_l = self.prms['letter_background_color']\n",
|
|
" fill_color_n = self.prms['number_background_color']\n",
|
|
"\n",
|
|
"\n",
|
|
" self.draw.rounded_rectangle(\n",
|
|
" (0, 0, self.width-width_border, self.height-width_border),\n",
|
|
" fill=fill_color_l,\n",
|
|
" outline=self.theme_params['poster_line_color'],\n",
|
|
" width=width_border,\n",
|
|
" radius=5)\n",
|
|
" \n",
|
|
" self.draw.rounded_rectangle(\n",
|
|
" (0, 0, proportion*self.width-width_border, self.height-width_border),\n",
|
|
" fill=fill_color_n,\n",
|
|
" outline=self.theme_params['poster_line_color'],\n",
|
|
" width=width_border,\n",
|
|
" radius=5)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_bus_number(self, bus_number=\"11\"):\n",
|
|
" text_color = 'black'\n",
|
|
" width_border = self.prms['width_border']\n",
|
|
" text_bbox = self.font.getbbox(str(bus_number))\n",
|
|
" font_width, font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
" offset_width = np.round((self.prms['proportion']*self.width-width_border)/2) - np.round(font_width/2)\n",
|
|
" text_position = (offset_width,0)\n",
|
|
" self.draw.text(\n",
|
|
" text_position,\n",
|
|
" bus_number,\n",
|
|
" fill=text_color,\n",
|
|
" font=self.font,\n",
|
|
" # align =\"center\"\n",
|
|
" )\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_bus_letter(self, bus_letter=\"E\"):\n",
|
|
" proportion = self.prms['proportion']\n",
|
|
" width_border = self.prms['width_border']\n",
|
|
" text_color = 'white'\n",
|
|
" text_bbox = self.font.getbbox(str(bus_letter))\n",
|
|
" font_width, font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
" offset_width = np.round((proportion*self.width-width_border)) + 0.75*np.round(font_width/2)\n",
|
|
" text_position = (offset_width,0)\n",
|
|
" self.draw.text(\n",
|
|
" text_position,\n",
|
|
" bus_letter,\n",
|
|
" fill=text_color,\n",
|
|
" font=self.font,\n",
|
|
" # align =\"center\"\n",
|
|
" )\n",
|
|
" pass\n",
|
|
"\n",
|
|
"\n",
|
|
"def bus_number_letter_image():\n",
|
|
" cartel = BusPoster(30, 60)\n",
|
|
" # cartel.start_day_mode()\n",
|
|
" cartel.start_night_mode()\n",
|
|
" cartel.start_draw()\n",
|
|
"\n",
|
|
" params = {\n",
|
|
" 'proportion': 0.6,\n",
|
|
" 'width_border': 1,\n",
|
|
" 'font_size': 25,\n",
|
|
" 'number_background_color': 'yellow',\n",
|
|
" 'letter_background_color': 'blue',\n",
|
|
" }\n",
|
|
"\n",
|
|
" cartel.set_params(params)\n",
|
|
" cartel.load_barlow()\n",
|
|
" cartel.set_colors()\n",
|
|
" cartel.set_bus_number()\n",
|
|
" cartel.set_bus_letter()\n",
|
|
" return cartel.get_image()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 40,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<matplotlib.image.AxesImage at 0x7f3db75d3760>"
|
|
]
|
|
},
|
|
"execution_count": 40,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
},
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"bus_poster = bus_number_letter_image()\n",
|
|
"plt.imshow(bus_poster)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 41,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"class TimeAnnouncement(MyDraw):\n",
|
|
"\n",
|
|
" def start_draw(self):\n",
|
|
" super().start_draw()\n",
|
|
" self.border = 1\n",
|
|
"\n",
|
|
" def set_background(self):\n",
|
|
" self.draw.rounded_rectangle(\n",
|
|
" (0, 0, self.width-0.5*self.border, self.height-0.5*self.border),\n",
|
|
" fill=\"#dcdcdc\",\n",
|
|
" outline=\"gray\",\n",
|
|
" width=self.border,\n",
|
|
" radius=1)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_base_text(self):\n",
|
|
" text = \"Tiempo aprox\"\n",
|
|
" text_color = self.theme_params['text_color']\n",
|
|
" self.load_barlow(font_size=11)\n",
|
|
" text_bbox = self.font.getbbox(text)\n",
|
|
" font_width, font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
" # print(font_width, font_height)\n",
|
|
" offset_width = (np.round((self.width-self.border)) - np.round(font_width))/2\n",
|
|
" text_position = (offset_width,5)\n",
|
|
" # text_position = (0, 0)\n",
|
|
" self.draw.text(\n",
|
|
" text_position,\n",
|
|
" text,\n",
|
|
" fill=text_color,\n",
|
|
" font=self.font,\n",
|
|
" align =\"center\"\n",
|
|
" )\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_min_max_text(self, min_time, max_time):\n",
|
|
"\n",
|
|
" text = \"Tiempo aprox\"\n",
|
|
" text_color = self.theme_params['text_color']\n",
|
|
" self.load_barlow(font_size=11)\n",
|
|
" text_bbox = self.font.getbbox(text)\n",
|
|
" base_font_width, base_font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
"\n",
|
|
" if (int(max_time) <= 1):\n",
|
|
" text = f\"< 1 min\"\n",
|
|
" else:\n",
|
|
" text = f'{min_time} a {max_time} min'\n",
|
|
" \n",
|
|
" self.load_barlow(font_size=18)\n",
|
|
" text_bbox = self.font.getbbox(text)\n",
|
|
" font_width, font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
" # print(font_width, font_height)\n",
|
|
" offset_width = (np.round((self.width-self.border)) - np.round(font_width))/2\n",
|
|
" offset_height = (np.round((self.height-self.border)) - np.round(base_font_height))/2\n",
|
|
" text_position = (offset_width,5+offset_height)\n",
|
|
" # text_position = (0, 0)\n",
|
|
" self.draw.text(\n",
|
|
" text_position,\n",
|
|
" text,\n",
|
|
" fill=text_color,\n",
|
|
" font=self.font,\n",
|
|
" align =\"center\"\n",
|
|
" )\n",
|
|
"\n",
|
|
"time_anmc = TimeAnnouncement(50, 80)\n",
|
|
"time_anmc.start_night_mode()\n",
|
|
"time_anmc.start_draw()\n",
|
|
"# time_anmc.set_background()\n",
|
|
"time_anmc.set_base_text()\n",
|
|
"time_anmc.set_min_max_text(min_time=0, max_time=1)\n",
|
|
"time_anmc.preview()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 42,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"class DistanceAnnouncement(MyDraw):\n",
|
|
"\n",
|
|
" def start_draw(self):\n",
|
|
" super().start_draw()\n",
|
|
" self.border = 1\n",
|
|
"\n",
|
|
" def set_background(self):\n",
|
|
" self.draw.rounded_rectangle(\n",
|
|
" (0, 0, self.width-0.5*self.border, self.height-0.5*self.border),\n",
|
|
" fill=\"#dcdcdc\",\n",
|
|
" outline=\"gray\",\n",
|
|
" width=self.border,\n",
|
|
" radius=1)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_base_text(self):\n",
|
|
" text = \"Distancia\"\n",
|
|
" text_color = self.theme_params['text_color']\n",
|
|
" self.load_barlow(font_size=11)\n",
|
|
" text_bbox = self.font.getbbox(text)\n",
|
|
" font_width, font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
" # print(font_width, font_height)\n",
|
|
" offset_width = (np.round((self.width-self.border)) - np.round(font_width))/2\n",
|
|
" text_position = (offset_width,5)\n",
|
|
" # text_position = (0, 0)\n",
|
|
" self.draw.text(\n",
|
|
" text_position,\n",
|
|
" text,\n",
|
|
" fill=text_color,\n",
|
|
" font=self.font,\n",
|
|
" align =\"center\"\n",
|
|
" )\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_distance_text(self, distance):\n",
|
|
"\n",
|
|
" text = \"Distancia\"\n",
|
|
" text_color = self.theme_params['text_color']\n",
|
|
" self.load_barlow(font_size=11)\n",
|
|
" text_bbox = self.font.getbbox(text)\n",
|
|
" base_font_width, base_font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
"\n",
|
|
"\n",
|
|
" text = f'{distance} km'\n",
|
|
" self.load_barlow(font_size=18)\n",
|
|
" text_bbox = self.font.getbbox(text)\n",
|
|
" font_width, font_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]\n",
|
|
" # print(font_width, font_height)\n",
|
|
" offset_width = (np.round((self.width-self.border)) - np.round(font_width))/2\n",
|
|
" offset_height = (np.round((self.height-self.border)) - np.round(base_font_height))/2\n",
|
|
" text_position = (offset_width,5+offset_height)\n",
|
|
" # text_position = (0, 0)\n",
|
|
" self.draw.text(\n",
|
|
" text_position,\n",
|
|
" text,\n",
|
|
" fill=text_color,\n",
|
|
" font=self.font,\n",
|
|
" align =\"center\"\n",
|
|
" )\n",
|
|
"\n",
|
|
"dist_anmc = DistanceAnnouncement(50, 80)\n",
|
|
"dist_anmc.start_night_mode()\n",
|
|
"dist_anmc.start_draw()\n",
|
|
"dist_anmc.border = 0\n",
|
|
"# dist_anmc.set_background()\n",
|
|
"dist_anmc.set_base_text()\n",
|
|
"dist_anmc.set_distance_text(distance=1)\n",
|
|
"dist_anmc.preview()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 43,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import requests\n",
|
|
"import io\n",
|
|
"class BusPlate():\n",
|
|
" def __init__(self, url=None) -> None:\n",
|
|
" if url is None:\n",
|
|
" self.url = \"https://matriculasdelmundo.com/gRCH1.php\"\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def set_url(self, url):\n",
|
|
" self.url = url\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def get_image(self):\n",
|
|
" if hasattr(self, 'image'):\n",
|
|
" return self.image\n",
|
|
" else:\n",
|
|
" print(\"Error: No se ha generado ninguna imagen aún.\")\n",
|
|
" return None\n",
|
|
"\n",
|
|
" def request_bus_plate(self, bus_plate=None):\n",
|
|
" if bus_plate is None:\n",
|
|
" self.bus_plate = \"AABB11\"\n",
|
|
" else:\n",
|
|
" self.bus_plate = bus_plate\n",
|
|
"\n",
|
|
" params = {\n",
|
|
" \"textRCH1\": self.bus_plate[0:2],\n",
|
|
" \"textRCH1A\": self.bus_plate[2:4],\n",
|
|
" \"textRCH1B\": self.bus_plate[4:],\n",
|
|
" \"textRCH1C\": \"\"\n",
|
|
" }\n",
|
|
"\n",
|
|
" self.response = requests.get(self.url, params=params)\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def save_bus_plate_image(self):\n",
|
|
" if self.response.status_code == 200:\n",
|
|
" filename = f\"/app/data/output/plate_{self.bus_plate}.png\" \n",
|
|
" with open(filename, \"wb\") as f:\n",
|
|
" f.write(self.response.content)\n",
|
|
" print(f\"Imagen generada guardada como '{filename}'\")\n",
|
|
" else:\n",
|
|
" print(\"Error al guardar la imagen generada\")\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def generate_image(self):\n",
|
|
" image_bytes = io.BytesIO(self.response.content)\n",
|
|
" self.image = Image.open(image_bytes)\n",
|
|
" self.image = self.image.convert(\"RGBA\") # Convertir a formato RGBA\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def resize_image(self, new_size):\n",
|
|
" proportion = np.min([self.image.size[0]/new_size[0], self.image.size[1]/new_size[1]])\n",
|
|
" nx, ny = int(np.round(image.size[0]/proportion)), int(np.round(image.size[1]/proportion))\n",
|
|
" self.image = self.image.resize((nx, ny))\n",
|
|
" pass\n",
|
|
"\n",
|
|
" def preview(self):\n",
|
|
" plt.imshow(self.image)\n",
|
|
" plt.axis('off')\n",
|
|
" plt.show()\n",
|
|
" pass"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 44,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class BusImage(MyDraw):\n",
|
|
" def __init__(self):\n",
|
|
" pass\n",
|
|
" \n",
|
|
" def load_image_from_url(self, url=None):\n",
|
|
" if(url is None):\n",
|
|
" # URL de la imagen en línea\n",
|
|
" url = \"https://img.freepik.com/iconos-gratis/autobus_318-574563.jpg\"\n",
|
|
"\n",
|
|
" # Descarga la imagen desde la URL\n",
|
|
" response = requests.get(url)\n",
|
|
" image_data = response.content\n",
|
|
" # Crea un objeto Image desde los datos descargados\n",
|
|
" self.image = Image.open(BytesIO(image_data))\n",
|
|
" # Crear una imagen en blanco del mismo tamaño que loaded_image con fondo blanco\n",
|
|
" background = Image.new(\"RGB\", self.image.size, self.theme_params['background_color'])\n",
|
|
"\n",
|
|
" # Pega la loaded_image en la imagen en blanco\n",
|
|
" background.paste(self.image, (0, 0), self.image)\n",
|
|
" \n",
|
|
" self.image = background\n",
|
|
"\n",
|
|
" # Calcula la posición para agregar la imagen cargada\n",
|
|
" image_position = (0, 0) # Cambia esto según tu diseño\n",
|
|
"\n",
|
|
" # Agrega la imagen a la imagen creada\n",
|
|
" self.image.paste(background, image_position)\n",
|
|
" pass"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 45,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"theme = 'night'\n",
|
|
"\n",
|
|
"panel_height, panel_width = 40, 80\n",
|
|
"n_panels = 3\n",
|
|
"full_panel = MyDraw(n_panels*panel_height, n_panels*panel_width)\n",
|
|
"full_panel.set_theme(theme)\n",
|
|
"full_panel.start_draw()\n",
|
|
"# full_panel.preview()\n",
|
|
"\n",
|
|
"bp = BusPlate()\n",
|
|
"plate = \"WXYZ88\"\n",
|
|
"bp.request_bus_plate(bus_plate=plate)\n",
|
|
"bp.generate_image()\n",
|
|
"bp.resize_image((40,80))\n",
|
|
"\n",
|
|
"dist_anmc = DistanceAnnouncement(50, 80)\n",
|
|
"dist_anmc.set_theme(theme)\n",
|
|
"dist_anmc.start_draw()\n",
|
|
"# dist_anmc.set_background()\n",
|
|
"dist_anmc.set_base_text()\n",
|
|
"dist_anmc.set_distance_text(distance=5)\n",
|
|
"\n",
|
|
"time_anmc = TimeAnnouncement(50, 80)\n",
|
|
"time_anmc.set_theme(theme)\n",
|
|
"time_anmc.start_draw()\n",
|
|
"# time_anmc.set_background()\n",
|
|
"time_anmc.set_base_text()\n",
|
|
"time_anmc.set_min_max_text(min_time=2, max_time=3)\n",
|
|
"\n",
|
|
"poster = BusPoster(30, 60)\n",
|
|
"poster.set_theme(theme)\n",
|
|
"poster.start_draw()\n",
|
|
"\n",
|
|
"poster_params = {\n",
|
|
" 'proportion': 0.6,\n",
|
|
" 'width_border': 1,\n",
|
|
" 'font_size': 25,\n",
|
|
" 'number_background_color': 'yellow',\n",
|
|
" 'letter_background_color': 'green',\n",
|
|
"}\n",
|
|
"\n",
|
|
"poster.set_params(poster_params)\n",
|
|
"poster.load_barlow()\n",
|
|
"poster.set_colors()\n",
|
|
"poster.set_bus_number(bus_number=\"20\")\n",
|
|
"poster.set_bus_letter(bus_letter=\"L\")\n",
|
|
"\n",
|
|
"bm = BusImage()\n",
|
|
"bm.set_theme(theme)\n",
|
|
"bm.load_image_from_url()\n",
|
|
"bm.crop_image(top_cut=165, bottom_cut=165)\n",
|
|
"bm.resize_image(target_width=80)\n",
|
|
"\n",
|
|
"full_panel.add_image(bp, (120, 80))\n",
|
|
"full_panel.add_image(dist_anmc, (90, 10))\n",
|
|
"full_panel.add_image(time_anmc, (160, 10))\n",
|
|
"full_panel.add_image(poster, (40, 80))\n",
|
|
"full_panel.add_image(bm, (5,20))\n",
|
|
"full_panel.get_image()\n",
|
|
"full_panel.save_image('/app/data/output.png')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3 (ipykernel)",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"orig_nbformat": 4
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|