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

import sys
import pixels


def lee_argumentos() -> tuple[str, float, int]:
    """Lee los argumentos de la línea de comandos y los valida."""
    if len(sys.argv) != 4:
        sys.exit("Uso: python3 process.py <imagen.gif> <factor_brillo> <desplazamiento>")

    imagen = sys.argv[1]

    try:
        brillo = float(sys.argv[2])
    except ValueError:
        sys.exit("Error: El factor de brillo debe ser un número real (float).")

    try:
        desplazamiento = int(sys.argv[3])
    except ValueError:
        sys.exit("Error: El desplazamiento debe ser un número entero (int).")

    return imagen, brillo, desplazamiento


def cambia_brillo(brillo: float):
    """
    Cambia el brillo de la imagen multiplicando cada componente RGB
    por el valor 'brillo'. Los valores mayores de 255 se limitan a 255.
    """
    ancho, alto = pixels.tam_lienzo()
    for x in range(ancho):
        for y in range(alto):
            r, g, b = pixels.lee(x, y)

            # Multiplicamos cada componente por el factor de brillo
            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):
    """
    Desplaza los colores sumando 'desplazamiento' a cada componente RGB.
    Los valores fuera del rango [0, 255] se recortan.
    """
    ancho, alto = pixels.tam_lienzo()
    for x in range(ancho):
        for y in range(alto):
            r, g, b = pixels.lee(x, y)

            # Sumamos el desplazamiento y recortamos al rango [0, 255]
            r = max(0, min(r + desplazamiento, 255))
            g = max(0, min(g + desplazamiento, 255))
            b = max(0, min(b + desplazamiento, 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 todos los requisitos especificados:

  • Lee correctamente los tres argumentos de la línea de comandos (imagen, brillo y desplazamiento)
  • Aplica el cambio de brillo multiplicando cada componente RGB por el factor y limitando a 255
  • Aplica el desplazamiento sumando el mismo valor entero a cada componente RGB y recortando al rango [0,255]
  • Tiene la función lee_argumentos() con la signatura especificada
  • Incluye la estructura main() con el código exacto requerido
  • Utiliza el módulo pixels.py tal como se menciona en el enunciado

Es fácil de leer y entender

El código es accesible para estudiantes principiantes gracias a:

  • Comentarios claros que explican cada paso del proceso
  • Nombres de variables y funciones descriptivos en español
  • Estructura modular con funciones bien definidas
  • Uso consistente de sangrías y espaciado adecuado
  • Manejo de errores con mensajes explicativos

Sigue buenas prácticas de programación

El programa muestra buenas prácticas como:

  • Validación de argumentos con mensajes de error específicos
  • Uso de try/except para manejar conversiones inválidas
  • Separación de responsabilidades en funciones distintas
  • Documentación con docstrings en cada función
  • Uso de funciones del módulo pixels de forma correcta

Recomendaciones de mejora

  1. Manejo de truncamiento en el brillo: Al convertir a entero con int() se pierde la precisión decimal. Considerar usar round() para un cálculo más preciso:
r = min(round(r * brillo), 255)

  1. Validación adicional de parámetros: Aunque el enunciado no lo especifica, podría añadirse una validación para asegurar que el factor de brillo sea positivo (aunque técnicamente el enunciado permite cualquier valor float).

  2. Optimización de código repetido: Las funciones cambia_brillo y cambia_desplazamiento tienen estructuras muy similares. Para evitar repetición, se podría crear una función auxiliar que itere por todos los píxeles y aplique una transformación específica a cada componente.

  3. Comprobación de formato de imagen: Aunque el enunciado asume que la imagen es GIF, podría añadirse una validación básica para confirmar que el archivo tiene extensión .gif.

  4. Uso de constantes para límites: Definir MAX_COLOR = 255 y MIN_COLOR = 0 mejoraría la legibilidad y facilitaría futuros cambios:

MAX_COLOR = 255
MIN_COLOR = 0

  1. Mensajes de error más específicos: En lugar de salir con mensajes genéricos, se podrían incluir ejemplos de uso correcto para ayudar al usuario a entender el formato esperado.

  2. Comprobación de rango para desplazamiento: Aunque el enunciado permite cualquier entero, podría añadirse una nota en los comentarios explicando que el desplazamiento puede afectar negativamente a la calidad de la imagen si es muy grande.