Skip to content

Revisión automática de la práctica 03-imagen

Este es el resultado de una revisión automática de la prácica 03-imagen, tal y como la hemos recogido de este repositorio de entrega. Por favor, ten en cuenta que al ser una revisión automática, realizada en parte con la ayuda de un asistente de inteligencia artificial generativa, puede incluir errores, y ser incorrecta. Pero leela con atención, porque creemos que puede tener información útil. Si tienes cualquier duda, o crees que la revisión es errónea, por favor, consulta con los profesores de la asignatura.

Comprobación de archivos con extension '.py'

  • Archivos Python excluidos de la búsqueda: pixels.py, invert.py
  • Archivos Python encontrados (excluyendo esos): process.py

Correcto, se elige process.py como entrega.

Comprobación con ficheros de plantilla

Los archivos son diferentes de los de la plantilla.

Comprobación con ficheros de solución

Los archivos son diferentes de los de la solución.

Revisión automática de programa

Programa revisado:

#!/usr/bin/env python3

"""Procesa una imagen para modificar su brillo y color."""

import sys
import pixels


def cambia_brillo(brillo: float):
    """
    Modifica el brillo de la imagen.

    Multiplica cada componente RGB por el factor de brillo.
    El valor máximo para cada componente es 255.
    """
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            r, g, b = pixels.lee(x, y)
            nuevo_r = min(255, int(r * brillo))
            nuevo_g = min(255, int(g * brillo))
            nuevo_b = min(255, int(b * brillo))
            pixels.pinta(x, y, (nuevo_r, nuevo_g, nuevo_b))


def cambia_desplazamiento(desplazamiento: int):
    """
    Desplaza los colores de la imagen.

    Suma el valor de desplazamiento a cada componente RGB.
    Los valores se mantienen en el rango [0, 255].
    """
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            r, g, b = pixels.lee(x, y)
            nuevo_r = max(0, min(255, r + desplazamiento))
            nuevo_g = max(0, min(255, g + desplazamiento))
            nuevo_b = max(0, min(255, b + desplazamiento))
            pixels.pinta(x, y, (nuevo_r, nuevo_g, nuevo_b))


def lee_argumentos() -> tuple[str, float, int]:
    """
    Lee los argumentos de la línea de comandos.

    Retorna el nombre del fichero, el brillo y el desplazamiento.
    """
    if len(sys.argv) != 4:
        print(f"Uso: python3 {sys.argv[0]} <imagen.gif> <brillo> <desplazamiento>")
        sys.exit(1)

    imagen = sys.argv[1]
    brillo = float(sys.argv[2])
    desplazamiento = int(sys.argv[3])
    return imagen, brillo, desplazamiento


def main():
    """Función principal del programa."""
    imagen, brillo, desplazamiento = lee_argumentos()
    pixels.prepara(imagen)
    cambia_brillo(brillo)
    cambia_desplazamiento(desplazamiento)
    pixels.espera()


if __name__ == "__main__":
    main()

Análisis

Cumple con el enunciado

El programa cumple con todos los requisitos especificados en el enunciado:

  • Las funciones cambia_brillo y cambia_desplazamiento modifican correctamente los componentes RGB de cada pixel según las reglas indicadas (multiplicar por un factor y sumar un desplazamiento, respetando los límites 0-255).
  • La función lee_argumentos procesa adecuadamente los argumentos de la línea de comandos y muestra un mensaje de uso claro si hay errores.
  • La estructura del programa sigue exactamente el esqueleto proporcionado, incluyendo la función main y la protección if __name__ == "__main__":.

Es fácil de leer y entender

El código es claro y accesible para estudiantes principiantes:

  • Los nombres de las funciones y variables están en español, alineándose con el enunciado.
  • Cada función tiene un propósito bien definido y está separada por comentarios explicativos.
  • El uso de min y max para limitar los valores de los componentes RGB es intuitivo y está bien documentado.
  • La estructura general del programa sigue un flujo lógico: lectura de argumentos, preparación de la imagen, aplicación de efectos y espera.

Sigue buenas prácticas de programación

El programa sigue buenas prácticas:

  • Separación de responsabilidades: Cada función realiza una tarea específica, lo que facilita la comprensión y mantenimiento.
  • Manejo de errores: La función lee_argumentos verifica el número de argumentos y muestra un mensaje de uso antes de salir.
  • Documentación: Las docstrings explican claramente el propósito de cada función, lo que es útil para estudiantes que están aprendiendo.
  • Cumple con PEP8: El código está bien formateado, con líneas no excesivamente largas, espaciado adecuado y nombres en snake_case.

Recomendaciones de mejora

  1. Redondeo en el brillo: Al multiplicar un componente RGB por un factor de brillo (float), truncar el resultado con int() puede llevar a una pérdida de precisión. Por ejemplo, 255 * 1.1 = 280.5, que truncado sería 280, pero redondeado sería 281. Aunque el enunciado no especifica redondeo, usar round() podría dar resultados más precisos en algunos casos.

  2. Claridad en comentarios: Aunque las docstrings son útiles, podrían añadirse comentarios breves dentro de las funciones para explicar operaciones como min(255, ...) o max(0, ...), especialmente para estudiantes que aún no están familiarizados con estas técnicas para limitar valores.

  3. Validación adicional de argumentos: La función lee_argumentos no verifica que el archivo tenga formato GIF. Aunque el enunciado menciona que se usará un archivo GIF, añadir una comprobación simple (por ejemplo, que el nombre termine en .gif) podría evitar errores difíciles de entender para principiantes.

  4. Uso de funciones auxiliares: Si bien el enunciado no lo pide, crear funciones auxiliares para limitar valores (como limita_valor(valor: int) -> int) podría mejorar la reutilización de código y la claridad, especialmente en cambia_brillo y cambia_desplazamiento.

  5. Orden de los imports: Aunque el código cumple con PEP8, es recomendable ordenar los imports alfabéticamente. En este caso, sys y pixels ya están bien colocados, pero en proyectos más grandes esta práctica ayuda a mantener consistencia.