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'
Comprobación con ficheros de plantilla
Comprobación con ficheros de solución
Revisión automática de programa
Análisis
Recomendaciones de mejora

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
import sys


def lee_argumentos():
    argumentos = sys.argv[1:]
    return argumentos


def cambia_brillo(brillo: float):
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            (r, g, b) = (pixels.lee(x, y))
            if r*float(brillo) > 255.0:
                r = 255
            else:
                r = int(r*float(brillo))
            if g*float(brillo) > 255.0:
                g = 255
            else:
                g = int(g*float(brillo))
            if b*float(brillo) > 255.0:
                b = 255
            else:
                b = int(b*float(brillo))
            pixels.pinta(x, y, (r, g, b))
    return True


def cambia_desplazamiento(desplazamiento: int):
    for x in range(pixels.ancho):
        for y in range(pixels.alto):
            (r, g, b) = pixels.lee(x, y)
            r = r + int(desplazamiento)
            if r > 255:
                r = r-255
            g = g + int(desplazamiento)
            if g > 255:
                g = g-255
            b = b + int(desplazamiento)
            if b > 255:
                b = b-255
            pixels.pinta(x, y, (r, g, b))


def main():
    imagen, brillo, desplazamiento = lee_argumentos()
    pixels.prepara(imagen)
    cambia_brillo(float(brillo))
    cambia_desplazamiento(int(desplazamiento))
    pixels.espera()


if __name__ == "__main__":
    main()

Análisis

Cumple con el enunciado

Lectura de argumentos: La función lee_argumentos() devuelve una tupla con los argumentos como cadenas de texto, pero no convierte el segundo argumento a float ni el tercero a int, como exige la signatura tuple[str, float, int]. Esto puede causar errores al usar valores no convertidos en otras funciones.
Cambio de brillo: La función cambia_brillo() multiplica cada componente RGB por el factor y lo limita a 255 si excede, pero no maneja valores negativos (ej: brillo=0.5 y r=0 daría 0, pero brillo=-1 no debería invertir colores).
Desplazamiento de colores: La función cambia_desplazamiento() suma el desplazamiento y usa una lógica incorrecta para valores >255 (ej: r=255 + 50 se convierte en r=50, en lugar de r=255). No maneja valores <0 (ej: desplazamiento=-100 y r=50 daría -50, que no es válido).

Es fácil de leer y entender

Variables y funciones: Los nombres en español (cambia_brillo, cambia_desplazamiento) son claros para un principiante.
Lógica de bucles: Los bucles anidados para recorrer píxeles son directos, pero la falta de comentarios y la repetición de código (ej: clamping manual en cada componente) dificulta la comprensión.
Errores en lógica: La forma de manejar desplazamientos (restar 255 en lugar de limitar) puede confundir, ya que no sigue el enunciado.

Sigue buenas prácticas de programación

Repetición de código: La lógica para clamping en cada componente RGB se repite, sin usar funciones auxiliares o min()/max().
Manejo de tipos: La conversión de tipos (float, int) se hace en main() en lugar de en lee_argumentos(), violando la separación de responsabilidades.
PEP8: Hay líneas con operaciones sin espaciado adecuado (ej: r*float(brillo) en lugar de r * brillo), y algunas condiciones podrían simplificarse.

Recomendaciones de mejora

Corregir lee_argumentos():
- Convertir el segundo argumento a float y el tercero a int antes de devolverlos.
- Ejemplo:
```
def lee_argumentos():
    return (sys.argv[1], float(sys.argv[2]), int(sys.argv[3]))
```
Mejorar el clamping en cambia_brillo():
- Usar min() y max() para evitar valores fuera de rango (0-255).
- Ejemplo:
```
r = min(max(int(r * brillo), 0), 255)
```
Corregir la lógica de cambia_desplazamiento():
- Sumar el desplazamiento y limitar los valores entre 0 y 255.
- Ejemplo:
```
r = min(max(r + desplazamiento, 0), 255)
```
Simplificar código repetido:
- Evitar duplicar la lógica de clamping para cada componente RGB. Usar una lista o bucle para procesarlos.
Validar argumentos:
- Añadir comprobaciones básicas para evitar errores por argumentos inválidos (ej: float no convertible o int no convertible).
Espaciado y formato PEP8:
- Agregar espacios en operaciones aritméticas (ej: r * brillo en lugar de r*brillo).
- Limitar líneas a 79 caracteres si son muy largas.