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 pixels, sys

def lee_argumentos():
    imagen = sys.argv[1]
    brillo_str=sys.argv[2]
    brillo_float=float(brillo_str)
    desplazamiento_str=sys.argv[3]
    desplazamiento_int = int(desplazamiento_str)
    return imagen, brillo_float, desplazamiento_int

def cambia_brillo(brillo: float):
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            (r,g,b) = pixels.lee(x,y)
            nuevo_R = brillo * r
            final_R = int(max(0,(min(255, nuevo_R))))
            nuevo_G = brillo * g
            final_G = int(max(0, (min(255, nuevo_G))))
            nuevo_B = brillo * b
            final_B = int(max(0, (min(255, nuevo_B))))
            pixels.pinta(x, y, (final_R, final_G, final_B))

def cambia_desplazamiento(desplazamiento: int):
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            (r,g,b) = pixels.lee(x,y)
            nuevo_r = desplazamiento + r
            final_r = int(max(0,min(255, nuevo_r)))
            nuevo_g = desplazamiento + g
            final_g = int(max(0, min(255, nuevo_g)))
            nuevo_b = desplazamiento + b
            final_b = int(max(0, min(255, nuevo_b)))
            pixels.pinta(x, y, (final_r, final_g, final_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 especificados:

  • Lee correctamente los tres argumentos de 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 valor a cada componente RGB y limitando entre 0 y 255
  • Tiene la estructura de funciones y main() especificada en el enunciado
  • Utiliza las funciones del módulo pixels según lo mostrado en el ejemplo invert.py

Es fácil de leer y entender

El código es comprensible para un principiante, aunque podría mejorar:

  • Usa variables con nombres descriptivos pero con inconsistencia en mayúsculas/minúsculas (nuevo_R vs nuevo_g)
  • Repite la lógica de clamping (min/max) para cada componente RGB, lo que dificulta la lectura
  • No tiene comentarios ni docstrings que expliquen el propósito de cada función
  • El orden de los parámetros en las funciones sigue el formato especificado

Sigue buenas prácticas de programación

El código sigue algunas buenas prácticas:

  • Usa tipos especificados en las firmas de funciones (float e int)
  • Limita correctamente los valores RGB entre 0 y 255
  • Aplica las transformaciones a todos los píxeles de la imagen

Pero presenta áreas de mejora:

  • No hay validación de argumentos (ej: verificar que el archivo GIF existe)
  • Se repite la lógica de clamping en ambas funciones, sin reutilizar código
  • No se siguen completamente las convenciones de estilo PEP8 (espaciado en operadores, nombres de variables)

Recomendaciones de mejora

  1. Consistencia en nombres de variables: Usar minúsculas para todos los nombres de variables según PEP8:

    # En lugar de:
nuevo_R = brillo * r
# Usar:
nuevo_r = brillo * r

  2. Evitar duplicación de código: Crear una función auxiliar para limitar valores:

    def limita_valor(valor: float) -> int:
    return int(max(0, min(255, round(valor))))

  3. Mejorar precisión en cálculos: Usar redondeo antes de convertir a entero:

    final_r = int(max(0, min(255, round(nuevo_r))))

  4. Agregar comentarios básicos: Explicar el propósito de cada función:

    def cambia_brillo(brillo: float):
    """Modifica el brillo de todos los píxeles multiplicando cada componente RGB por el factor"""
    ...

  5. Manejo de valores negativos en brillo: Aunque el enunciado no lo menciona, el factor de brillo podría ser negativo:

    # Actualmente funciona, pero podría aclararse en comentarios
# que se permite brillo negativo (invierte colores y ajusta)

  6. Espaciado PEP8: Añadir espacios en operadores para mejorar legibilidad:

    # En lugar de:
nuevo_r = brillo * r
# Mejor:
nuevo_r = brillo * r

  7. Validación básica de argumentos: Aunque no es obligatorio según el enunciado, añadir comprobaciones simples:

    # Verificar que se pasen 3 argumentos
if len(sys.argv) != 4:
    print("Uso: process.py <imagen> <brillo> <desplazamiento>")
    sys.exit(1)