Descripción de la Actividad Objetivo: Utilizar los patrones de diseño Comando y Cadena de Responsabilidad para desarrollar una aplicación móvil de edición de imágenes que permita aplicar filtros y ajustes de forma secuencial y controlada.
Una aplicación de edición de imágenes para dispositivos móviles que permite a los usuarios aplicar múltiples filtros y ajustes a sus fotos. Los usuarios pueden deshacer y rehacer cambios de manera flexible y controlada, utilizando una interfaz intuitiva.
Implementar el patrón Comando para encapsular todas las operaciones de edición como objetos de comando. Usar el patrón Cadena de Responsabilidad para manejar una secuencia de filtros y ajustes aplicados a una imagen. Crear comandos concretos para diferentes ajustes y filtros. Desarrollar una interfaz de usuario que permita aplicar y revertir los comandos de edición fácilmente. Implementación
Interfaz Comando:
Método ejecutar para aplicar el comando. Método deshacer para revertir el comando. Clase ComandoBrillo: Implementa Comando.
Aumenta o disminuye el brillo de la imagen. Clase ComandoContraste: Implementa Comando.
Ajusta el contraste de la imagen. Clase GestorComandos:
Almacena una lista de comandos ejecutados y proporciona métodos para deshacer y rehacer comandos. Clase Filtro: (Cadena de Responsabilidad)
Procesa un ajuste y pasa el control al siguiente filtro en la cadena.
Explicacion en base al codigo:
Definición de Clases:
Interfaz Comando: Define los métodos Ejecutar y Deshacer que deben ser implementados
por todas las clases que actúan como comandos. Estos métodos permiten aplicar y revertir
un comando, respectivamente.
Clase ComandoBrillo: Implementa la interfaz Comando y proporciona
funcionalidad para ajustar el brillo de una imagen.
Clase ComandoContraste: También implementa la interfaz
Comando y permite ajustar el contraste de una imagen.
Clase GestorComandos: Se encarga de almacenar una lista
de comandos ejecutados, lo que facilita deshacer y rehacer acciones sobre la imagen.
Clase Filtro: Implementa el patrón Cadena de Responsabilidad
al procesar un ajuste sobre la imagen y pasar el control al siguiente filtro en la cadena.
Los usuarios seleccionan ajustes de una lista de comandos disponibles y aplican estos a la imagen. Cada comando es registrado por el GestorComandos para permitir deshacer o rehacer. Los ajustes son procesados secuencialmente por objetos Filtro, permitiendo a cada filtro añadir su efecto antes de pasar la imagen modificada al siguiente filtro en la cadena.
Explicacion en base al codigo:
Lógica de Interacción:
Cuando los usuarios seleccionan un ajuste de una lista de comandos disponibles,
se crea un objeto de comando correspondiente (por ejemplo, ComandoBrillo o ComandoContraste).
Estos comandos se ejecutan y se registran en el GestorComandos,
lo que permite que los usuarios deshagan o rehagan acciones según sea necesario.
Los ajustes son procesados secuencialmente por objetos Filtro.
Cada filtro modifica la imagen según su función (por ejemplo, ajustar el brillo o el contraste) y luego pasa la imagen al siguiente filtro en la cadena. Esto permite que los ajustes se apliquen de manera ordenada y secuencial a la imagen.
Verificar que cada comando se ejecuta y deshace correctamente, manteniendo la integridad de los estados de la imagen. Asegurar que la cadena de filtros procesa los efectos en orden y que los resultados son los esperados. Evaluar la usabilidad de la interfaz de usuario para asegurar que los comandos sean accesibles y fáciles de usar.
using System;
using System.Collections.Generic;
// Interfaz Comando
public interface IComando
{
void Ejecutar(); // Método para ejecutar el comando
void Deshacer(); // Método para deshacer el comando
}
// Clase ComandoBrillo
public class ComandoBrillo : IComando
{
private readonly Imagen imagen;
private readonly int valorBrilloAnterior;
private readonly int nuevoValorBrillo;
// Constructor que recibe la imagen y el nuevo valor de brillo
public ComandoBrillo(Imagen imagen, int nuevoValorBrillo)
{
this.imagen = imagen;
this.valorBrilloAnterior = imagen.Brillo; // Guardar el brillo actual antes de aplicar el cambio
this.nuevoValorBrillo = nuevoValorBrillo; // Nuevo valor de brillo
}
// Implementación del método Ejecutar de la interfaz IComando
public void Ejecutar()
{
imagen.AjustarBrillo(nuevoValorBrillo); // Aplicar el nuevo brillo a la imagen
}
// Implementación del método Deshacer de la interfaz IComando
public void Deshacer()
{
imagen.AjustarBrillo(valorBrilloAnterior); // Deshacer el cambio de brillo, restaurando el valor anterior
}
}
// Clase ComandoContraste
public class ComandoContraste : IComando
{
private readonly Imagen imagen;
private readonly int valorContrasteAnterior;
private readonly int nuevoValorContraste;
// Constructor que recibe la imagen y el nuevo valor de contraste
public ComandoContraste(Imagen imagen, int nuevoValorContraste)
{
this.imagen = imagen;
this.valorContrasteAnterior = imagen.Contraste; // Guardar el contraste actual antes de aplicar el cambio
this.nuevoValorContraste = nuevoValorContraste; // Nuevo valor de contraste
}
// Implementación del método Ejecutar de la interfaz IComando
public void Ejecutar()
{
imagen.AjustarContraste(nuevoValorContraste); // Aplicar el nuevo contraste a la imagen
}
// Implementación del método Deshacer de la interfaz IComando
public void Deshacer()
{
imagen.AjustarContraste(valorContrasteAnterior); // Deshacer el cambio de contraste, restaurando el valor anterior
}
}
// Clase GestorComandos
public class GestorComandos
{
private readonly Stack<IComando> historialComandos = new Stack<IComando>(); // Pila para almacenar los comandos ejecutados
// Método para ejecutar un comando
public void EjecutarComando(IComando comando)
{
comando.Ejecutar(); // Ejecutar el comando
historialComandos.Push(comando); // Agregar el comando al historial
}
// Método para deshacer el último comando ejecutado
public void Deshacer()
{
if (historialComandos.Count > 0)
{
var ultimoComando = historialComandos.Pop(); // Obtener el último comando del historial
ultimoComando.Deshacer(); // Deshacer el último comando
}
else
{
Console.WriteLine("No hay comandos para deshacer.");
}
}
}
// Clase Imagen (solo para simular una imagen)
public class Imagen
{
public int Brillo { get; private set; } // Propiedad para el brillo de la imagen
public int Contraste { get; private set; } // Propiedad para el contraste de la imagen
// Constructor que recibe valores iniciales de brillo y contraste
public Imagen(int brilloInicial, int contrasteInicial)
{
Brillo = brilloInicial; // Asignar el brillo inicial
Contraste = contrasteInicial; // Asignar el contraste inicial
}
// Método para ajustar el brillo de la imagen
public void AjustarBrillo(int nuevoValorBrillo)
{
Brillo = nuevoValorBrillo; // Asignar el nuevo valor de brillo
Console.WriteLine($"Brillo ajustado a: {Brillo}"); // Mostrar mensaje de ajuste de brillo
}
// Método para ajustar el contraste de la imagen
public void AjustarContraste(int nuevoValorContraste)
{
Contraste = nuevoValorContraste; // Asignar el nuevo valor de contraste
Console.WriteLine($"Contraste ajustado a: {Contraste}"); // Mostrar mensaje de ajuste de contraste
}
}
// Clase Filtro (Cadena de Responsabilidad)
public abstract class Filtro
{
protected Filtro siguienteFiltro; // Referencia al siguiente filtro en la cadena
// Método para establecer el siguiente filtro en la cadena
public void EstablecerSiguienteFiltro(Filtro siguienteFiltro)
{
this.siguienteFiltro = siguienteFiltro;
}
// Método abstracto para aplicar el filtro a la imagen
public abstract void Aplicar(Imagen imagen);
}
// Filtro para aplicar brillo
public class FiltroBrillo : Filtro
{
// Implementación del método Aplicar de la clase Filtro
public override void Aplicar(Imagen imagen)
{
imagen.AjustarBrillo(imagen.Brillo + 10); // Ajustar el brillo de la imagen (solo para demostración)
Console.WriteLine("Filtro de brillo aplicado."); // Mostrar mensaje de aplicación del filtro de brillo
siguienteFiltro?.Aplicar(imagen); // Pasar la imagen al siguiente filtro en la cadena
}
}
// Filtro para aplicar contraste
public class FiltroContraste : Filtro
{
// Implementación del método Aplicar de la clase Filtro
public override void Aplicar(Imagen imagen)
{
imagen.AjustarContraste(imagen.Contraste + 5); // Ajustar el contraste de la imagen (solo para demostración)
Console.WriteLine("Filtro de contraste aplicado."); // Mostrar mensaje de aplicación del filtro de contraste
siguienteFiltro?.Aplicar(imagen); // Pasar la imagen al siguiente filtro en la cadena
}
}
class Program
{
static void Main(string[] args)
{
// Crear una imagen (solo para demostración)
Imagen imagen = new Imagen(50, 20);
// Crear comandos para ajustar brillo y contraste
IComando comandoBrillo = new ComandoBrillo(imagen, 60);
IComando comandoContraste = new ComandoContraste(imagen, 30);
// Ejemplo de
revisado esta incompleto