Nombre: Adrián Solis Ruiz
Numero de control: 20210641
Carrera: Ing. en Sistemas Computacionales
Materia: Patrones de diseño de Software
- Video: Representa los vídeos que serán analizados para detectar emociones.
- FacialFeatureDetector: Esta clase se encarga de detectar características faciales en los fotogramas del vídeo, lo cual es fundamental para el análisis de emociones.
- EmotionAnalyzer: Esta clase analiza las características faciales detectadas para determinar las emociones expresadas por los sujetos en el vídeo.
- UIManager: Esta clase proporciona una interfaz gráfica para que los usuarios interactúen con el sistema.
- Database: Esta clase se encarga de gestionar el almacenamiento de los datos recopilados durante el análisis de emociones en los vídeos.
- EmotionModel: Esta clase representa el modelo utilizado para clasificar las emociones detectadas en los vídeos.
- VideoProcessor: Esta clase coordina el proceso de carga, procesamiento y análisis de los vídeos educativos.
- Patron Singleton: se utiliza para garantizar que una clase tenga una única instancia y proporcionar un punto de acceso global a esa instancia.
- Patron Factory: se utiliza para crear objetos sin especificar la clase exacta del objeto que se creará.
- Patron Strategy: se utiliza para definir una familia de algoritmos, encapsular cada uno de ellos y hacerlos intercambiables. Permite que el algoritmo varíe independientemente de los clientes que lo utilizan.
- Patron Observer: se utiliza para definir una dependencia uno a muchos entre objetos, de modo que cuando el estado de un objeto cambia, todos sus dependientes son notificados y actualizados automáticamente.
class Video:
def __init__(self, path: str, duration: int, resolution: str):
self.path = path
self.duration = duration
self.resolution = resolution
def load_video(self):
# Implementación para cargar el vídeo desde el sistema de archivos
pass
def get_duration(self) -> int:
return self.duration
def get_resolution(self) -> str:
return self.resolution
class FacialFeatureDetector:
def detect_features(self, frame) -> FacialFeatures:
# Implementación para detectar características faciales en el fotograma
pass
class EmotionAnalyzer:
def analyze_emotions(self, features: FacialFeatures) -> Emotions:
# Implementación para analizar las características faciales y determinar las emociones
pass
class UIManager:
def display_results(self, emotions: Emotions):
# Implementación para mostrar los resultados en la interfaz de usuario
pass
class Database:
def __init__(self, db_path: str):
self.db_path = db_path
def save_emotions(self, emotions: Emotions):
# Implementación para guardar las emociones en la base de datos
pass
def retrieve_emotions(self, video: Video) -> Emotions:
# Implementación para recuperar las emociones asociadas a un vídeo
pass
class EmotionModel:
def __init__(self, categories: List[str]):
self.categories = categories
def classify_emotion(self, features: FacialFeatures) -> Emotion:
# Implementación para clasificar la emoción basada en las características faciales
pass
class VideoProcessor:
def __init__(self, facial_feature_detector, emotion_analyzer, ui_manager, database):
self.facial_feature_detector = facial_feature_detector
self.emotion_analyzer = emotion_analyzer
self.ui_manager = ui_manager
self.database = database
def process_video(self, video: Video):
# Implementación para procesar el vídeo y analizar las emociones
pass
class Database:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
# Inicializar la conexión a la base de datos aquí
return cls._instance
def save_emotions(self, emotions):
# Lógica para guardar emociones en la base de datos
def retrieve_emotions(self, video):
# Lógica para recuperar emociones de la base de datos
class DetectorFactory:
@staticmethod
def create_facial_feature_detector():
return FacialFeatureDetector()
@staticmethod
def create_emotion_analyzer():
return EmotionAnalyzer()
class EmotionAnalyzer:
def __init__(self, strategy):
self._strategy = strategy
def set_strategy(self, strategy):
self._strategy = strategy
def analyze_emotions(self, features):
return self._strategy.analyze(features)
class EmotionAnalysisStrategy:
def analyze(self, features):
raise NotImplementedError
class RuleBasedStrategy(EmotionAnalysisStrategy):
def analyze(self, features):
# Implementación específica de análisis de emociones basado en reglas
pass
class NeuralNetworkStrategy(EmotionAnalysisStrategy):
def analyze(self, features):
# Implementación específica de análisis de emociones basado en redes neuronales
pass
class VideoProcessor:
def __init__(self):
self._observers = []
def attach(self, observer):
self._observers.append(observer)
def detach(self, observer):
self._observers.remove(observer)
def notify_observers(self, video):
for observer in self._observers:
observer.update(video)
def process_video(self, video):
# Lógica para procesar el vídeo
# Después de procesar el vídeo, notificar a los observadores
self.notify_observers(video)
class EmotionDetectionObserver:
def update(self, video):
# Lógica para manejar la detección de emociones en el vídeo procesado
pass
- Video: Esta clase encapsula los atributos y comportamientos relacionados con los videos educativos que se van a analizar.
- FacialFeatureDetector: Esta clase representa un componente del sistema encargado de detectar características faciales en los fotogramas de los videos.
- EmotionAnalyzer: Esta clase analiza las características faciales detectadas para determinar las emociones expresadas en el video.
- UIManager: Esta clase proporciona una interfaz para que los usuarios interactúen con el sistema y visualicen los resultados de la detección de emociones.
- Database: Esta clase gestiona el almacenamiento y la recuperación de datos relacionados con las emociones detectadas durante el análisis de los videos.
- EmotionModel: Esta clase representa el modelo utilizado para clasificar las emociones detectadas en los videos.
- VideoProcessor: Esta clase coordina el procesamiento de videos para la detección de emociones.
- Patron Singleton: El patrón Singleton se utiliza para garantizar que una clase tenga una sola instancia y proporcionar un punto de acceso global a esa instancia.
- Patron Factory: El patrón Factory se utiliza para crear objetos sin especificar la clase exacta del objeto que se creará. La creación de objetos se delega a una clase de fábrica.
- Patron Observer: El patrón Observer se utiliza para definir una dependencia uno-a-muchos entre objetos, de modo que cuando un objeto cambia de estado, todos sus dependientes son notificados y actualizados automáticamente.
- Patron Facade: El patrón Facade se utiliza para proporcionar una interfaz unificada y simplificada a un conjunto de interfaces en un subsistema.
class Video {
private String path;
private int duration;
private String resolution;
public void loadVideo() {
// Method to load the video file.
}
public int getDuration() {
return duration;
}
public String getResolution() {
return resolution;
}
}
class FacialFeatureDetector {
public FacialFeatures detectFeatures(Frame frame) {
// Method to detect facial features from the given frame.
}
}
class EmotionAnalyzer {
public Emotions analyzeEmotions(FacialFeatures features) {
// Method to analyze facial features and determine emotions.
}
}
class UIManager {
public void displayResults(Emotions emotions) {
// Method to display emotion detection results to the user.
}
}
class Database {
public void saveEmotions(Emotions emotions) {
// Implementación para almacenar las emociones detectadas
}
public Emotions retrieveEmotions(Video video) {
// Implementación para recuperar las emociones detectadas para un video dado
}
}
class EmotionModel {
private String[] categories;
public Emotion classifyEmotion(FacialFeatures features) {
// Implementación para clasificar la emoción basada en las características faciales
}
}
class VideoProcessor {
public void processVideo(Video video) {
// Implementación para procesar el video, detectar características faciales, analizar emociones, etc.
}
}
public class VideoProcessor {
private static VideoProcessor instance;
private VideoProcessor() {
// Constructor privado para evitar instanciación externa
}
public static VideoProcessor getInstance() {
if (instance == null) {
instance = new VideoProcessor();
}
return instance;
}
// Métodos de procesamiento de video
}
public class DetectorFactory {
public static FacialFeatureDetector createFacialFeatureDetector() {
// Lógica para crear un detector de características faciales
return new FacialFeatureDetector();
}
public static EmotionAnalyzer createEmotionAnalyzer() {
// Lógica para crear un analizador de emociones
return new EmotionAnalyzer();
}
}
import java.util.ArrayList;
import java.util.List;
public class VideoProcessor {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
private void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
public void processVideo() {
// Procesamiento de video
// Luego de procesar el video, notificar a los observadores
notifyObservers();
}
}
public interface Observer {
void update();
}
public class UIManager implements Observer {
@Override
public void update() {
// Actualizar la interfaz de usuario con los resultados del procesamiento de video
}
}
public class VideoProcessorFacade {
private VideoProcessor videoProcessor;
private FacialFeatureDetector facialFeatureDetector;
private EmotionAnalyzer emotionAnalyzer;
private Database database;
public VideoProcessorFacade() {
videoProcessor = new VideoProcessor();
facialFeatureDetector = new FacialFeatureDetector();
emotionAnalyzer = new EmotionAnalyzer();
database = new Database();
}
public void processVideoWithEmotionDetection(Video video) {
// Lógica para procesar el video con detección de emociones
// Utilizando los componentes internos (facialFeatureDetector, emotionAnalyzer, etc.)
}
}
