뇌졸중 회복 장치

# 로봇 장갑 제어 시스템
class RoboticGloveController:
    def __init__(self):
        self.fingers = {
            'thumb': FingerActuator(2),      # 2 관절
            'index': FingerActuator(3),      # 3 관절
            'middle': FingerActuator(3),
            'ring': FingerActuator(3),
            'pinky': FingerActuator(3)
        }
        self.emg_sensor = EMGSensor()
        self.force_sensors = ForceSensorArray()

    def detect_intention(self):
        # EMG 신호로 환자의 의도 감지
        emg_signals = self.emg_sensor.read()

        # 근육 활성화 패턴 분석
        intention = self.classify_gesture(emg_signals)

        return intention

    def assist_movement(self, intention, assist_level=0.7):
        # 의도된 손동작 지원
        if intention == 'grasp':
            for finger_name, actuator in self.fingers.items():
                target_angle = self.get_grasp_angle(finger_name)
                actuator.move_to(target_angle, assist_level)

        elif intention == 'pinch':
            self.fingers['thumb'].move_to(45, assist_level)
            self.fingers['index'].move_to(45, assist_level)

        elif intention == 'point':
            self.fingers['index'].move_to(0, assist_level)
            # 나머지 손가락 굽히기

    def provide_haptic_feedback(self):
        # 물체 접촉 시 햅틱 피드백
        forces = self.force_sensors.read()
        for finger, force in forces.items():
            if force > 1.0:  # 1N 이상
                self.fingers[finger].activate_vibration(force)

# 보행 동기화 FES 시스템
class GaitSyncFES:
    def __init__(self):
        self.gait_detector = GaitPhaseDetector()
        self.stimulator = FESStimulator()
        self.imu_sensor = IMUSensor()

    def update(self):
        # 보행 주기 감지
        gait_phase = self.gait_detector.detect_phase(
            self.imu_sensor.get_ankle_angle()
        )

        # 유각기 초기에 발목 배측굴곡 자극
        if gait_phase == 'swing_initial':
            # 전경골근(Tibialis Anterior) 자극
            self.stimulator.activate(
                muscle='tibialis_anterior',
                pulse_width=300,  # μs
                frequency=30,     # Hz
                amplitude=25,     # mA
                duration=0.3      # 초
            )

        # 입각기에는 자극 중지
        elif gait_phase == 'stance':
            self.stimulator.deactivate()

    def adapt_intensity(self, performance_score):
        # 환자의 성과에 따라 자극 강도 조절
        if performance_score > 0.8:
            # 성과 좋음 → 자극 감소
            self.stimulator.reduce_amplitude(5)
        elif performance_score < 0.5:
            # 성과 낮음 → 자극 증가
            self.stimulator.increase_amplitude(5)

# EEG 기반 운동 상상 분류기
import numpy as np
from scipy.signal import butter, filtfilt
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

class MotorImageryBCI:
    def __init__(self):
        self.sampling_rate = 250  # Hz
        self.classifier = LinearDiscriminantAnalysis()
        self.trained = False

    def preprocess_eeg(self, eeg_data):
        # 밴드패스 필터 (8-30 Hz, μ와 β 리듬)
        b, a = butter(4, [8, 30], btype='bandpass',
                      fs=self.sampling_rate)
        filtered = filtfilt(b, a, eeg_data, axis=1)

        return filtered

    def extract_features(self, eeg_data):
        # 파워 스펙트럼 밀도(PSD) 특징 추출
        features = []
        for channel in eeg_data:
            # μ 리듬 (8-12 Hz) 파워
            mu_power = np.mean(channel[8:13]**2)
            # β 리듬 (13-30 Hz) 파워
            beta_power = np.mean(channel[13:31]**2)
            features.extend([mu_power, beta_power])

        return np.array(features)

    def classify_intention(self, eeg_data):
        # 전처리
        filtered = self.preprocess_eeg(eeg_data)

        # 특징 추출
        features = self.extract_features(filtered)

        # 분류
        intention = self.classifier.predict([features])[0]
        confidence = self.classifier.predict_proba([features]).max()

        return intention, confidence

    def train(self, training_data, labels):
        # 분류기 학습
        features_list = []
        for trial in training_data:
            filtered = self.preprocess_eeg(trial)
            features = self.extract_features(filtered)
            features_list.append(features)

        self.classifier.fit(features_list, labels)
        self.trained = True