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]:
    """Lee y valida los argumentos de línea de comandos."""
    if len(sys.argv) != 4:
        print(f"Uso correcto: {sys.argv[0]} <imagen> <brillo> <desplazamiento>")
        sys.exit(1)

    try:
        imagen = sys.argv[1]
        brillo = float(sys.argv[2])
        desplazamiento = int(sys.argv[3])
    except ValueError:
        print("Error: <brillo> debe ser flotante y <desplazamiento> un entero.")
        sys.exit(1)

    return imagen, brillo, desplazamiento


def cambia_brillo(brillo: float):
    """Modifica el brillo de cada píxel multiplicando sus componentes RGB."""
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            r, g, b = pixels.lee(x, y)
            nuevo_color = tuple(min(255, int(c * brillo)) for c in (r, g, b))
            pixels.pinta(x, y, nuevo_color)


def cambia_desplazamiento(desplazamiento: int):
    """Desplaza los valores RGB sumando un desplazamiento, manteniéndolos en [0, 255]."""
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            r, g, b = pixels.lee(x, y)
            nuevo_color = tuple(max(0, min(255, c + desplazamiento)) for c in (r, g, b))
            pixels.pinta(x, y, nuevo_color)


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 en el enunciado:

  • Lee correctamente los tres argumentos de línea de comandos (imagen, brillo y desplazamiento)
  • Implementa las funciones cambia_brillo y cambia_desplazamiento con las signaturas y comportamientos solicitados
  • Incluye la función lee_argumentos que valida los tipos de datos y muestra mensajes de error adecuados
  • La estructura de main() coincide exactamente con la solicitada
  • El código importa los módulos necesarios (sys y pixels)
  • Aplica las transformaciones a todos los píxeles de la imagen

Es fácil de leer y entender

El código es bastante claro para un principiante:

  • Usa nombres descriptivos para las funciones y variables
  • Incluye comentarios explicativos en todas las funciones
  • Organiza el código en secciones lógicas con funciones bien definidas
  • El uso de comprensiones de tuplas es conciso pero puede resultar difícil de entender para alumnos nuevos

Sigue buenas prácticas de programación

El programa sigue buenas prácticas:

  • Valida los argumentos de entrada y maneja errores adecuadamente
  • Separa responsabilidades en funciones distintas
  • Mantiene el orden de importación correcto (módulos estándar primero)
  • Usa sys.exit(1) para indicar errores en la ejecución
  • Respeta los tipos especificados en las signaturas de funciones

Recomendaciones de mejora

  1. Manejo de truncamiento en el brillo: En la función cambia_brillo, al convertir a int se está truncando el valor en lugar de redondearlo. Para un procesamiento más preciso, considera usar round():
nuevo_color = tuple(min(255, round(c * brillo)) for c in (r, g, b))
  1. Claridad en comprensiones de tuplas: Para hacer más legible el código para principiantes, podrías desglosar las comprensiones de tuplas:
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 = min(255, round(r * brillo))
            nuevo_g = min(255, round(g * brillo))
            nuevo_b = min(255, round(b * brillo))
            pixels.pinta(x, y, (nuevo_r, nuevo_g, nuevo_b))

  1. Documentación más detallada: Aunque hay docstrings, podrían incluir más detalles sobre cómo se procesan los valores límite (por ejemplo, qué ocurre cuando el desplazamiento haría que un color fuera negativo o mayor que 255).

  2. Espaciado en operaciones matemáticas: Añadir espacios en las operaciones matemáticas dentro de las comprensiones podría mejorar la legibilidad:

nuevo_color = tuple(max(0, min(255, c + desplazamiento)) for c in (r, g, b))
# podría ser
nuevo_color = tuple(max(0, min(255, c + desplazamiento)) for c in (r, g, b))
  1. Validación adicional de rangos: Aunque no se solicita explícitamente, validar que el brillo sea un valor positivo (dado que un brillo negativo no tendría sentido) podría evitar resultados inesperados.