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:

import sys
import pixels


def lee_argumentos() -> tuple[str, float, int]:
    if len(sys.argv) != 4:
        print("Uso: python3 process.py <imagen.gif> <brillo: float> <desplazamiento: int>")
        sys.exit(1)
    imagen = sys.argv[1]
    try:
        brillo = float(sys.argv[2])
        desplazamiento = int(sys.argv[3])
    except ValueError:
        print("Error: el brillo debe ser un número decimal y el desplazamiento un entero.")
        sys.exit(1)
    return imagen, brillo, desplazamiento


def cambia_brillo(brillo: float):
    ancho = pixels.ancho()
    alto = pixels.alto()
    for x in range(ancho):
        for y in range(alto):
            r, g, b = pixels.color(x, y)
            r = min(int(r * brillo), 255)
            g = min(int(g * brillo), 255)
            b = min(int(b * brillo), 255)
            pixels.pinta(x, y, (r, g, b))

def cambia_desplazamiento(desplazamiento: int):
    ancho = pixels.ancho()
    alto = pixels.alto()
    for x in range(ancho):
        for y in range(alto):
            r, g, b = pixels.color(x, y)
            r = min(max(r + desplazamiento, 0), 255)
            g = min(max(g + desplazamiento, 0), 255)
            b = min(max(b + desplazamiento, 0), 255)
            pixels.pinta(x, y, (r, g, b))




def main():
    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 los requisitos básicos del enunciado:

  • Lee correctamente los tres argumentos de la línea de comandos y valida su tipo.
  • Aplica el cambio de brillo multiplicando cada componente RGB por el factor y limitando a 255.
  • Aplica el desplazamiento sumando el valor a cada componente RGB y ajustando entre 0 y 255.

Pero tiene un problema en la implementación del brillo: al convertir directamente a int (ej. int(r * brillo)), se trunca el valor en lugar de redondearlo. Esto puede causar resultados inesperados (ej. brillo=1.9 y r=100 → 190 truncado a 190, pero si r=101 → 191.9 se truncaría a 191 en lugar de redondear a 192).

Es fácil de leer y entender

  • Las funciones tienen nombres descriptivos en español (cambia_brillo, cambia_desplazamiento).
  • El uso de bucles anidados para recorrer todos los píxeles es claro y directo.
  • Falta documentación: no hay comentarios ni docstrings que expliquen el propósito de las funciones o pasos clave, lo que dificulta la comprensión para un principiante.

Sigue buenas prácticas de programación

  • Validación de argumentos: maneja correctamente errores en los tipos de entrada (float e int).
  • Uso de funciones separadas: divide la lógica en funciones con responsabilidades claras.
  • Problemas de estilo PEP8:
    • No hay espacios consistentes en operaciones como r = min(int(r * brillo), 255) (falta espacio alrededor de *).
    • Algunas líneas podrían exceder los 79 caracteres recomendados por PEP8.
    • No hay dos líneas en blanco entre funciones, como sugiere PEP8.

Recomendaciones de mejora

  1. Redondear en lugar de truncar en cambia_brillo para evitar distorsiones:

    r = min(round(r * brillo), 255)

    Esto da resultados más precisos al aplicar factores no enteros.

  2. Agregar docstrings a todas las funciones para explicar su propósito y parámetros:

    def cambia_brillo(brillo: float):
    """Multiplica cada componente RGB de todos los píxeles por 'brillo' y limita a 255."""

  3. Mejorar el estilo PEP8:

    • Añadir espacios en operaciones matemáticas: r * brillo → r * brillo.
    • Limitar la longitud de las líneas (ej. dividir comentarios largos).
    • Dejar dos líneas en blanco entre definiciones de funciones.

  4. Evitar repetición de código entre cambia_brillo y cambia_desplazamiento:

    • Crear una función auxiliar para procesar cada componente con una operación genérica, aunque el enunciado no lo exija explícitamente. Ejemplo: 
      def ajusta_componente(valor: int, operacion: callable) -> int:
    return min(max(operacion(valor), 0), 255)

  5. Validar que el archivo GIF existe antes de procesarlo, para evitar errores en pixels.prepara(). El enunciado no lo menciona, pero es una buena práctica.