사례 연구

7.2.1 도입 배경

심부전 환자의 30일 재입원율은 의료비 증가와 환자 예후 악화의 주요 원인입니다. 서울대학교병원 심혈관센터는 NYHA Class II-III 심부전 환자를 대상으로 원격 모니터링 프로그램을 도입하여 조기 악화 감지 및 예방적 개입을 목표로 했습니다.

7.2.2 시스템 구성

7.2.3 알고리즘 및 프로토콜

// 심부전 악화 조기 감지 알고리즘
class HeartFailureMonitor {
    constructor(patientBaseline) {
        this.baseline = patientBaseline;
        this.alertThresholds = {
            weightGain: {
                moderate: 1.0,  // kg/일
                severe: 1.5,    // kg/일
                critical: 2.0   // kg/일 또는 3일간 2kg 이상
            },
            bloodPressure: {
                systolicLow: 90,
                systolicHigh: 160,
                diastolicHigh: 100
            },
            oxygenSaturation: {
                warning: 94,
                critical: 90
            },
            activityDecline: {
                threshold: 30  // 기준 대비 % 감소
            }
        };
    }

    // 일일 평가 수행
    async evaluateDaily(todayData) {
        const assessment = {
            timestamp: new Date(),
            patientId: this.baseline.patientId,
            riskScore: 0,
            alerts: [],
            recommendations: []
        };

        // 체중 변화 분석
        const weightAnalysis = this.analyzeWeightTrend(todayData.weight);
        if (weightAnalysis.alert) {
            assessment.alerts.push(weightAnalysis);
            assessment.riskScore += weightAnalysis.severity * 30;
        }

        // 혈압 분석
        const bpAnalysis = this.analyzeBloodPressure(todayData.bloodPressure);
        if (bpAnalysis.alert) {
            assessment.alerts.push(bpAnalysis);
            assessment.riskScore += bpAnalysis.severity * 25;
        }

        // 산소포화도 분석
        const spo2Analysis = this.analyzeOxygenSaturation(todayData.spo2);
        if (spo2Analysis.alert) {
            assessment.alerts.push(spo2Analysis);
            assessment.riskScore += spo2Analysis.severity * 25;
        }

        // 증상 분석
        const symptomAnalysis = this.analyzeSymptoms(todayData.symptoms);
        if (symptomAnalysis.alert) {
            assessment.alerts.push(symptomAnalysis);
            assessment.riskScore += symptomAnalysis.severity * 20;
        }

        // 종합 위험도 판정
        assessment.riskLevel = this.determineRiskLevel(assessment.riskScore);
        assessment.recommendations = this.generateRecommendations(assessment);

        return assessment;
    }

    // 체중 추세 분석
    analyzeWeightTrend(currentWeight) {
        const recentWeights = this.getRecentWeights(7);  // 최근 7일
        const avgWeight = recentWeights.reduce((a, b) => a + b, 0) / recentWeights.length;
        const dailyChange = currentWeight - recentWeights[recentWeights.length - 1];
        const weeklyChange = currentWeight - avgWeight;

        // 급격한 체중 증가 감지
        if (dailyChange >= this.alertThresholds.weightGain.critical) {
            return {
                alert: true,
                type: 'weight_critical',
                severity: 3,
                message: `급격한 체중 증가 감지: ${dailyChange.toFixed(1)}kg/일`,
                data: { currentWeight, dailyChange, weeklyChange }
            };
        }

        // 3일간 체중 변화
        const threeDay = recentWeights.slice(-3);
        const threeDayChange = currentWeight - threeDay[0];
        if (threeDayChange >= 2.0) {
            return {
                alert: true,
                type: 'weight_trend',
                severity: 2,
                message: `3일간 ${threeDayChange.toFixed(1)}kg 증가`,
                data: { currentWeight, threeDayChange }
            };
        }

        return { alert: false };
    }

    // 위험도 수준 결정
    determineRiskLevel(score) {
        if (score >= 80) return 'critical';
        if (score >= 60) return 'high';
        if (score >= 40) return 'moderate';
        if (score >= 20) return 'low';
        return 'normal';
    }

    // 권장 사항 생성
    generateRecommendations(assessment) {
        const recommendations = [];

        switch (assessment.riskLevel) {
            case 'critical':
                recommendations.push({
                    action: 'immediate_contact',
                    description: '즉시 담당 의료진에게 연락하세요',
                    urgency: 'urgent'
                });
                recommendations.push({
                    action: 'prepare_hospital',
                    description: '병원 방문 준비를 하세요',
                    urgency: 'urgent'
                });
                break;

            case 'high':
                recommendations.push({
                    action: 'contact_today',
                    description: '오늘 중 담당 간호사에게 연락하세요',
                    urgency: 'same_day'
                });
                recommendations.push({
                    action: 'fluid_restriction',
                    description: '수분 섭취를 제한하세요 (1.5L/일 이하)',
                    urgency: 'immediate'
                });
                break;

            case 'moderate':
                recommendations.push({
                    action: 'increase_monitoring',
                    description: '측정 빈도를 늘려주세요 (1일 3회)',
                    urgency: 'today'
                });
                recommendations.push({
                    action: 'sodium_restriction',
                    description: '저염식을 더 철저히 지켜주세요',
                    urgency: 'ongoing'
                });
                break;

            default:
                recommendations.push({
                    action: 'continue_monitoring',
                    description: '현재 상태를 유지하세요',
                    urgency: 'routine'
                });
        }

        return recommendations;
    }
}

7.2.4 성과 및 결과

7.3.1 프로젝트 개요

제1형 및 제2형 당뇨병 환자를 대상으로 연속혈당측정기(CGM)와 인슐린 펌프 데이터를 실시간으로 모니터링하여 혈당 조절 최적화를 목표로 한 프로젝트입니다. 특히 혈당 변동성이 큰 환자와 저혈당 고위험 환자에게 집중 관리를 제공했습니다.

7.3.2 기술 구현

// CGM 데이터 분석 엔진
class CGMAnalyticsEngine {
    constructor() {
        this.targetRange = { low: 70, high: 180 };  // mg/dL
        this.hypoglycemiaThreshold = 54;
        this.hyperglycemiaThreshold = 250;
    }

    // 시간대별 혈당 패턴 분석
    analyzeGlucosePatterns(readings, days = 14) {
        const hourlyData = this.groupByHour(readings);

        const patterns = {
            fasting: this.analyzeFastingGlucose(hourlyData),
            postMeal: {
                breakfast: this.analyzePostMeal(readings, 'breakfast'),
                lunch: this.analyzePostMeal(readings, 'lunch'),
                dinner: this.analyzePostMeal(readings, 'dinner')
            },
            overnight: this.analyzeOvernightPattern(hourlyData),
            timeInRange: this.calculateTIR(readings),
            glycemicVariability: this.calculateGV(readings)
        };

        return patterns;
    }

    // Time in Range (TIR) 계산
    calculateTIR(readings) {
        const total = readings.length;
        if (total === 0) return null;

        let inRange = 0;
        let belowRange = 0;
        let aboveRange = 0;
        let veryLow = 0;
        let veryHigh = 0;

        for (const reading of readings) {
            if (reading.value < 54) {
                veryLow++;
                belowRange++;
            } else if (reading.value < 70) {
                belowRange++;
            } else if (reading.value <= 180) {
                inRange++;
            } else if (reading.value <= 250) {
                aboveRange++;
            } else {
                veryHigh++;
                aboveRange++;
            }
        }

        return {
            timeInRange: (inRange / total * 100).toFixed(1),
            timeBelowRange: (belowRange / total * 100).toFixed(1),
            timeAboveRange: (aboveRange / total * 100).toFixed(1),
            timeVeryLow: (veryLow / total * 100).toFixed(1),
            timeVeryHigh: (veryHigh / total * 100).toFixed(1),
            target: {
                inRange: '>70%',
                belowRange: '<4%',
                veryLow: '<1%'
            }
        };
    }

    // 혈당 변동성 (CV) 계산
    calculateGV(readings) {
        const values = readings.map(r => r.value);
        const mean = values.reduce((a, b) => a + b, 0) / values.length;
        const variance = values.reduce((sum, val) =>
            sum + Math.pow(val - mean, 2), 0) / values.length;
        const sd = Math.sqrt(variance);
        const cv = (sd / mean * 100).toFixed(1);

        return {
            mean: mean.toFixed(0),
            standardDeviation: sd.toFixed(1),
            coefficientOfVariation: cv,
            interpretation: cv < 36 ? '안정적' : '변동성 높음',
            target: '<36%'
        };
    }

    // 저혈당 패턴 분석
    analyzeHypoglycemiaPatterns(readings) {
        const hypoEvents = readings.filter(r => r.value < 70);

        if (hypoEvents.length === 0) {
            return { frequency: 0, patterns: [] };
        }

        // 시간대별 분포
        const hourDistribution = new Array(24).fill(0);
        hypoEvents.forEach(event => {
            const hour = new Date(event.timestamp).getHours();
            hourDistribution[hour]++;
        });

        // 주요 저혈당 시간대 식별
        const peakHours = [];
        for (let i = 0; i < 24; i++) {
            if (hourDistribution[i] > 2) {
                peakHours.push({
                    hour: i,
                    count: hourDistribution[i],
                    timeOfDay: this.getTimeOfDay(i)
                });
            }
        }

        return {
            frequency: hypoEvents.length,
            averagePerDay: (hypoEvents.length / 14).toFixed(1),
            peakHours: peakHours.sort((a, b) => b.count - a.count),
            severeEvents: hypoEvents.filter(e => e.value < 54).length,
            recommendations: this.generateHypoRecommendations(peakHours)
        };
    }

    // 저혈당 예방 권고사항
    generateHypoRecommendations(peakHours) {
        const recommendations = [];

        for (const peak of peakHours) {
            if (peak.timeOfDay === '새벽') {
                recommendations.push({
                    issue: '새벽 저혈당',
                    suggestion: '취침 전 기저 인슐린 용량 10-20% 감량 고려',
                    action: 'review_basal'
                });
            } else if (peak.timeOfDay === '오전') {
                recommendations.push({
                    issue: '오전 저혈당',
                    suggestion: '아침 식사 인슐린 타이밍 및 용량 검토',
                    action: 'review_bolus_breakfast'
                });
            } else if (peak.timeOfDay === '오후') {
                recommendations.push({
                    issue: '오후 저혈당',
                    suggestion: '점심-저녁 사이 간식 추가 또는 점심 인슐린 감량',
                    action: 'review_bolus_lunch'
                });
            }
        }

        return recommendations;
    }

    getTimeOfDay(hour) {
        if (hour >= 0 && hour < 6) return '새벽';
        if (hour >= 6 && hour < 12) return '오전';
        if (hour >= 12 && hour < 18) return '오후';
        return '저녁/밤';
    }
}

7.3.3 환자 교육 및 피드백 시스템

// 개인화된 피드백 생성기
class PersonalizedFeedbackGenerator {
    constructor(patientProfile) {
        this.patient = patientProfile;
        this.feedbackHistory = [];
    }

    // 주간 리포트 생성
    generateWeeklyReport(cgmData, insulinData) {
        const analysis = this.analyzeCGMData(cgmData);
        const insulinAnalysis = this.analyzeInsulinUsage(insulinData);

        const report = {
            period: {
                start: cgmData[0].timestamp,
                end: cgmData[cgmData.length - 1].timestamp
            },
            summary: this.generateSummary(analysis),
            achievements: this.identifyAchievements(analysis),
            challenges: this.identifyChallenges(analysis),
            actionItems: this.generateActionItems(analysis, insulinAnalysis),
            comparison: this.compareWithPrevious(analysis),
            motivationalMessage: this.generateMotivation(analysis)
        };

        return report;
    }

    // 요약 생성
    generateSummary(analysis) {
        const tir = parseFloat(analysis.timeInRange.timeInRange);
        const cv = parseFloat(analysis.glycemicVariability.coefficientOfVariation);

        let summary = '';

        if (tir >= 70) {
            summary = `훌륭합니다! 이번 주 목표 범위 시간이 ${tir}%로 `;
            summary += `목표(70% 이상)를 달성하셨습니다. `;
        } else if (tir >= 50) {
            summary = `좋은 진전을 보이고 계십니다. 목표 범위 시간이 ${tir}%입니다. `;
            summary += `목표 달성까지 ${(70 - tir).toFixed(0)}%가 남았습니다. `;
        } else {
            summary = `이번 주 목표 범위 시간은 ${tir}%입니다. `;
            summary += `함께 개선 방안을 찾아보겠습니다. `;
        }

        if (cv < 36) {
            summary += `혈당 변동성(${cv}%)이 안정적입니다.`;
        } else {
            summary += `혈당 변동성(${cv}%)이 다소 높습니다. 식사와 인슐린 타이밍을 점검해보세요.`;
        }

        return summary;
    }

    // 성취 식별
    identifyAchievements(analysis) {
        const achievements = [];
        const previous = this.getPreviousWeekAnalysis();

        // TIR 개선
        if (previous) {
            const tirImprovement = parseFloat(analysis.timeInRange.timeInRange) -
                                   parseFloat(previous.timeInRange.timeInRange);
            if (tirImprovement > 5) {
                achievements.push({
                    type: 'tir_improvement',
                    title: 'TIR 향상',
                    description: `목표 범위 시간이 ${tirImprovement.toFixed(1)}% 향상되었습니다!`
                });
            }
        }

        // 저혈당 감소
        const hypoFreq = analysis.hypoglycemiaPatterns?.frequency || 0;
        if (hypoFreq === 0) {
            achievements.push({
                type: 'no_hypo',
                title: '저혈당 없음',
                description: '이번 주 저혈당이 한 번도 없었습니다!'
            });
        }

        // 측정 순응도
        const expectedReadings = 7 * 288;  // 5분마다 측정 기준
        const actualReadings = analysis.totalReadings;
        const compliance = (actualReadings / expectedReadings * 100);
        if (compliance >= 90) {
            achievements.push({
                type: 'high_compliance',
                title: '우수한 순응도',
                description: `CGM 착용률이 ${compliance.toFixed(0)}%입니다!`
            });
        }

        return achievements;
    }

    // 동기 부여 메시지
    generateMotivation(analysis) {
        const messages = {
            excellent: [
                "정말 잘하고 계십니다! 이 습관을 유지해주세요.",
                "당신의 노력이 결과로 나타나고 있습니다!",
                "건강한 혈당 관리의 모범을 보여주고 계십니다."
            ],
            good: [
                "좋은 진전입니다! 조금씩 더 나아지고 있어요.",
                "꾸준한 노력이 빛을 발하고 있습니다.",
                "작은 변화들이 모여 큰 차이를 만듭니다."
            ],
            needsWork: [
                "함께 더 나은 방법을 찾아보겠습니다.",
                "포기하지 마세요. 한 걸음씩 나아가고 있습니다.",
                "어려움을 겪을 때 의료진이 함께합니다."
            ]
        };

        const tir = parseFloat(analysis.timeInRange.timeInRange);
        let category;

        if (tir >= 70) category = 'excellent';
        else if (tir >= 50) category = 'good';
        else category = 'needsWork';

        const categoryMessages = messages[category];
        return categoryMessages[Math.floor(Math.random() * categoryMessages.length)];
    }
}

7.3.4 프로젝트 성과

7.4.1 프로젝트 배경

고령 인구 증가와 함께 낙상은 노인 건강의 주요 위협이 되고 있습니다. 경기도 소재 15개 노인요양시설에서 웨어러블 기기와 환경 센서를 결합한 통합 낙상 예방 시스템을 도입했습니다.

7.4.2 시스템 아키텍처

// 낙상 감지 및 예방 시스템
class FallPreventionSystem {
    constructor(facilityId) {
        this.facilityId = facilityId;
        this.residents = new Map();
        this.environmentSensors = new Map();
        this.mlModel = new FallRiskPredictor();
    }

    // 입소자 등록
    registerResident(resident, wearableDevice) {
        this.residents.set(resident.id, {
            profile: resident,
            device: wearableDevice,
            riskScore: this.calculateBaselineRisk(resident),
            activityHistory: [],
            fallHistory: []
        });
    }

    // 기본 낙상 위험도 계산
    calculateBaselineRisk(resident) {
        let score = 0;

        // 연령 위험도
        if (resident.age >= 85) score += 25;
        else if (resident.age >= 75) score += 15;
        else if (resident.age >= 65) score += 10;

        // 낙상 이력
        if (resident.fallHistory?.length > 0) {
            const recentFalls = resident.fallHistory.filter(
                f => (Date.now() - new Date(f.date)) < 365 * 24 * 60 * 60 * 1000
            );
            score += recentFalls.length * 15;
        }

        // 보행 보조기구 사용
        if (resident.mobilityAid === 'wheelchair') score += 10;
        else if (resident.mobilityAid === 'walker') score += 15;
        else if (resident.mobilityAid === 'cane') score += 8;

        // 인지 기능
        if (resident.cognitiveStatus === 'dementia') score += 20;
        else if (resident.cognitiveStatus === 'mild_impairment') score += 10;

        // 시력 문제
        if (resident.visionImpairment) score += 10;

        // 고위험 약물 복용
        const highRiskMeds = ['sedatives', 'antihypertensives', 'diuretics'];
        const medRisk = resident.medications?.filter(
            m => highRiskMeds.includes(m.category)
        ).length || 0;
        score += medRisk * 8;

        return Math.min(score, 100);
    }

    // 실시간 낙상 감지
    async detectFall(deviceId, sensorData) {
        const { acceleration, gyroscope, pressure } = sensorData;

        // 가속도 기반 감지
        const totalAcceleration = Math.sqrt(
            acceleration.x ** 2 +
            acceleration.y ** 2 +
            acceleration.z ** 2
        );

        // 급격한 가속도 변화 감지
        if (totalAcceleration > 3.0) {  // 3G 이상
            // 후속 분석: 정지 상태 확인
            const postImpact = await this.waitForPostImpact(deviceId, 2000);

            if (postImpact.isStationary) {
                // 자세 확인 (누워있는지)
                const orientation = this.calculateOrientation(postImpact.acceleration);

                if (orientation.isHorizontal) {
                    return this.triggerFallAlert(deviceId, {
                        type: 'detected_fall',
                        confidence: 0.85,
                        impactAcceleration: totalAcceleration,
                        orientation,
                        timestamp: new Date()
                    });
                }
            }
        }

        return null;
    }

    // 낙상 알림 트리거
    async triggerFallAlert(deviceId, fallData) {
        const resident = this.findResidentByDevice(deviceId);

        // 즉시 알림 전송
        await this.notificationService.sendUrgent({
            type: 'FALL_DETECTED',
            resident: {
                id: resident.id,
                name: resident.profile.name,
                room: resident.profile.roomNumber,
                photo: resident.profile.photoUrl
            },
            location: await this.getLocation(deviceId),
            timestamp: fallData.timestamp,
            confidence: fallData.confidence,
            recipients: [
                { type: 'station', id: this.getNearestStation(resident.profile.roomNumber) },
                { type: 'staff', shift: 'current' },
                { type: 'emergency', if: fallData.confidence > 0.9 }
            ]
        });

        // 환자 상태 확인 요청 (웨어러블 진동)
        await this.device.requestConfirmation(deviceId, {
            message: '괜찮으세요? 30초 내 버튼을 누르지 않으면 직원이 확인합니다.',
            timeout: 30000
        });

        // 낙상 이력 기록
        this.recordFallEvent(resident.id, fallData);

        return {
            alertId: generateUUID(),
            status: 'sent',
            responseRequired: true
        };
    }

    // 낙상 위험 예측 (예방적)
    async predictFallRisk(residentId) {
        const resident = this.residents.get(residentId);
        const recentActivity = resident.activityHistory.slice(-24 * 7);  // 최근 1주

        // 특징 추출
        const features = {
            baselineRisk: resident.riskScore,
            gaitSpeed: this.calculateGaitSpeed(recentActivity),
            gaitVariability: this.calculateGaitVariability(recentActivity),
            activityLevel: this.calculateActivityLevel(recentActivity),
            sleepQuality: await this.getSleepQuality(residentId),
            medicationChanges: await this.getMedicationChanges(residentId),
            vitalSigns: await this.getRecentVitals(residentId)
        };

        // ML 모델 예측
        const prediction = await this.mlModel.predict(features);

        return {
            residentId,
            riskLevel: prediction.riskLevel,  // low, moderate, high, critical
            riskScore: prediction.score,
            contributingFactors: prediction.factors,
            recommendations: this.generatePreventionPlan(prediction)
        };
    }

    // 예방 계획 생성
    generatePreventionPlan(prediction) {
        const plan = [];

        for (const factor of prediction.factors) {
            switch (factor.type) {
                case 'gait_deterioration':
                    plan.push({
                        intervention: '물리치료 강화',
                        description: '균형 및 근력 운동 프로그램 참여',
                        priority: 'high',
                        referral: 'physical_therapy'
                    });
                    break;

                case 'medication_risk':
                    plan.push({
                        intervention: '약물 검토',
                        description: '담당 의사와 고위험 약물 복용 시간 조정 상담',
                        priority: 'medium',
                        referral: 'physician'
                    });
                    break;

                case 'environmental_hazard':
                    plan.push({
                        intervention: '환경 개선',
                        description: `${factor.location} 지역 안전 점검 필요`,
                        priority: 'high',
                        referral: 'facility_management'
                    });
                    break;

                case 'sleep_disturbance':
                    plan.push({
                        intervention: '수면 관리',
                        description: '야간 배뇨 시 보조 인력 배치',
                        priority: 'medium',
                        referral: 'nursing'
                    });
                    break;
            }
        }

        return plan;
    }
}

7.4.3 환경 모니터링 통합

# 환경 센서 기반 위험 감지
class EnvironmentalRiskMonitor:
    """시설 환경 센서 모니터링"""

    def __init__(self, facility_id):
        self.facility_id = facility_id
        self.sensors = {}
        self.risk_zones = []

    def analyze_floor_sensors(self, sensor_data):
        """바닥 압력 센서 분석"""
        risks = []

        for location, data in sensor_data.items():
            # 미끄러운 바닥 감지 (습기)
            if data.get('moisture_level', 0) > 30:
                risks.append({
                    'type': 'wet_floor',
                    'location': location,
                    'severity': 'high' if data['moisture_level'] > 50 else 'medium',
                    'action': '즉시 청소 필요'
                })

            # 걸림 위험 감지 (물체)
            if data.get('obstacle_detected'):
                risks.append({
                    'type': 'obstacle',
                    'location': location,
                    'severity': 'medium',
                    'action': '장애물 제거 필요'
                })

        return risks

    def analyze_lighting(self, lighting_data):
        """조명 상태 분석"""
        risks = []

        for zone, data in lighting_data.items():
            # 야간 조명 부족
            if data['time_of_day'] == 'night' and data['lux'] < 50:
                risks.append({
                    'type': 'low_lighting',
                    'location': zone,
                    'severity': 'high',
                    'current_lux': data['lux'],
                    'recommended_lux': 100,
                    'action': '야간 보조등 점검'
                })

            # 조명 고장
            if data['status'] == 'malfunction':
                risks.append({
                    'type': 'light_malfunction',
                    'location': zone,
                    'severity': 'medium',
                    'action': '조명 교체 필요'
                })

        return risks

    def generate_daily_risk_report(self):
        """일일 환경 위험 보고서"""
        report = {
            'date': datetime.now().date(),
            'facility_id': self.facility_id,
            'high_risk_zones': [],
            'incidents': [],
            'maintenance_needed': [],
            'summary': {}
        }

        # 위험 지역 집계
        all_risks = self.get_all_current_risks()

        for risk in all_risks:
            if risk['severity'] == 'high':
                report['high_risk_zones'].append(risk)

        # 24시간 사고 집계
        report['incidents'] = self.get_incidents_last_24h()

        # 요약 통계
        report['summary'] = {
            'total_risks': len(all_risks),
            'high_severity': len([r for r in all_risks if r['severity'] == 'high']),
            'falls_detected': len([i for i in report['incidents'] if i['type'] == 'fall']),
            'near_misses': len([i for i in report['incidents'] if i['type'] == 'near_miss'])
        }

        return report

7.4.4 프로젝트 성과

7.5.1 프로젝트 배경

COVID-19 팬데믹 기간 중 의료 시스템 과부하를 방지하고 경증 환자의 재택 치료를 지원하기 위해 전국적인 원격 모니터링 시스템을 긴급 구축했습니다. 단기간에 수만 명의 환자를 모니터링할 수 있는 확장 가능한 시스템이 필요했습니다.

7.5.2 긴급 구축 타임라인

7.5.3 시스템 구현

// COVID-19 재택치료 모니터링 시스템
class CovidHomeMonitoring {
    constructor() {
        this.escalationLevels = {
            green: { interval: 12 * 60 },   // 12시간마다
            yellow: { interval: 6 * 60 },   // 6시간마다
            orange: { interval: 3 * 60 },   // 3시간마다
            red: { interval: 1 * 60 }       // 1시간마다
        };
    }

    // 환자 상태 평가
    assessPatientStatus(vitals, symptoms) {
        const assessment = {
            spo2: this.assessOxygen(vitals.spo2),
            temperature: this.assessTemperature(vitals.temperature),
            heartRate: this.assessHeartRate(vitals.heartRate),
            respiratoryRate: this.assessRespiratoryRate(vitals.respiratoryRate),
            symptoms: this.assessSymptoms(symptoms)
        };

        // 종합 위험도 결정
        const riskLevels = Object.values(assessment).map(a => a.risk);

        if (riskLevels.includes('critical')) {
            return { level: 'red', action: 'emergency_transfer' };
        } else if (riskLevels.includes('high')) {
            return { level: 'orange', action: 'urgent_consult' };
        } else if (riskLevels.includes('moderate')) {
            return { level: 'yellow', action: 'close_monitoring' };
        }

        return { level: 'green', action: 'routine_monitoring' };
    }

    // 산소포화도 평가
    assessOxygen(spo2) {
        if (spo2 < 90) {
            return {
                risk: 'critical',
                message: '즉시 119 신고 및 응급 이송 필요',
                value: spo2
            };
        } else if (spo2 < 94) {
            return {
                risk: 'high',
                message: '담당 의료진 즉시 연락 필요',
                value: spo2
            };
        } else if (spo2 < 96) {
            return {
                risk: 'moderate',
                message: '1시간 후 재측정 필요',
                value: spo2
            };
        }
        return { risk: 'low', message: '정상 범위', value: spo2 };
    }

    // 체온 평가
    assessTemperature(temp) {
        if (temp >= 39.5) {
            return {
                risk: 'high',
                message: '고열 지속. 해열제 복용 후 재측정',
                value: temp
            };
        } else if (temp >= 38.0) {
            return {
                risk: 'moderate',
                message: '발열. 충분한 수분 섭취 필요',
                value: temp
            };
        }
        return { risk: 'low', message: '정상 체온', value: temp };
    }

    // 증상 평가
    assessSymptoms(symptoms) {
        const criticalSymptoms = [
            'severe_breathing_difficulty',
            'chest_pain',
            'confusion',
            'blue_lips'
        ];

        const highRiskSymptoms = [
            'breathing_difficulty',
            'persistent_chest_pressure',
            'inability_to_stay_awake'
        ];

        if (symptoms.some(s => criticalSymptoms.includes(s))) {
            return {
                risk: 'critical',
                message: '응급 증상 발현. 즉시 119 신고',
                symptoms: symptoms.filter(s => criticalSymptoms.includes(s))
            };
        }

        if (symptoms.some(s => highRiskSymptoms.includes(s))) {
            return {
                risk: 'high',
                message: '고위험 증상. 의료진 상담 필요',
                symptoms: symptoms.filter(s => highRiskSymptoms.includes(s))
            };
        }

        return { risk: 'low', message: '경증 증상', symptoms };
    }

    // 자동 에스컬레이션
    async handleEscalation(patientId, assessment) {
        const patient = await this.getPatient(patientId);
        const previousLevel = patient.currentLevel;

        // 상태 악화 시
        if (this.isWorsening(previousLevel, assessment.level)) {
            await this.escalate(patient, assessment);
        }

        // 레벨별 조치
        switch (assessment.level) {
            case 'red':
                await this.emergencyProtocol(patient, assessment);
                break;
            case 'orange':
                await this.urgentConsultation(patient, assessment);
                break;
            case 'yellow':
                await this.increaseMonitoring(patient, assessment);
                break;
            case 'green':
                await this.routineFollowUp(patient, assessment);
                break;
        }

        // 상태 업데이트
        await this.updatePatientStatus(patientId, assessment);
    }

    // 응급 프로토콜
    async emergencyProtocol(patient, assessment) {
        // 1. 119 자동 연락 (환자 동의 시)
        if (patient.consent.autoEmergencyCall) {
            await this.call119({
                patientInfo: patient,
                vitals: assessment,
                location: patient.address
            });
        }

        // 2. 담당 의료진 알림
        await this.notifyMedicalTeam(patient, {
            type: 'EMERGENCY',
            priority: 'CRITICAL',
            assessment
        });

        // 3. 보호자 알림
        await this.notifyEmergencyContacts(patient, assessment);

        // 4. 이송 준비 안내
        await this.sendPatientGuidance(patient, {
            type: 'emergency_preparation',
            instructions: [
                '신분증과 건강보험증을 준비하세요',
                '현재 복용 중인 약 목록을 준비하세요',
                '구급대원이 도착할 때까지 현관문을 열어두세요',
                '가능하면 마스크를 착용하세요'
            ]
        });
    }
}

7.5.4 대규모 운영 결과

7.6.1 프로젝트 개요

인공관절(무릎, 고관절) 수술 환자의 조기 퇴원 및 재택 재활을 지원하기 위한 원격 모니터링 프로그램입니다. 재활 운동 수행 상태, 관절 가동 범위, 통증 수준을 지속적으로 모니터링하여 최적의 회복을 유도합니다.

7.6.2 모니터링 시스템

// 정형외과 재활 모니터링
class OrthopedicRehabMonitor {
    constructor(surgeryType) {
        this.surgeryType = surgeryType;
        this.milestones = this.defineMilestones(surgeryType);
    }

    defineMilestones(surgeryType) {
        if (surgeryType === 'total_knee_replacement') {
            return {
                week1: {
                    flexionGoal: 70,     // 도
                    extensionGoal: 0,
                    walkingGoal: 50,     // 미터
                    painTarget: 5        // VAS (0-10)
                },
                week2: {
                    flexionGoal: 90,
                    extensionGoal: 0,
                    walkingGoal: 200,
                    painTarget: 4
                },
                week4: {
                    flexionGoal: 110,
                    extensionGoal: 0,
                    walkingGoal: 500,
                    painTarget: 3
                },
                week8: {
                    flexionGoal: 120,
                    extensionGoal: 0,
                    walkingGoal: 1000,
                    painTarget: 2
                },
                week12: {
                    flexionGoal: 130,
                    extensionGoal: 0,
                    walkingGoal: 2000,
                    painTarget: 1
                }
            };
        }
        // 다른 수술 유형의 마일스톤 정의
        return {};
    }

    // 관절 가동 범위 측정 (웨어러블 센서)
    measureRangeOfMotion(sensorData) {
        const { accelerometer, gyroscope } = sensorData;

        // 센서 융합 알고리즘으로 각도 계산
        const flexionAngle = this.calculateFlexion(accelerometer, gyroscope);
        const extensionAngle = this.calculateExtension(accelerometer, gyroscope);

        return {
            flexion: flexionAngle,
            extension: extensionAngle,
            timestamp: new Date(),
            quality: this.assessMeasurementQuality(sensorData)
        };
    }

    // 재활 진행 상황 평가
    evaluateProgress(patientData, weekNumber) {
        const milestone = this.milestones[`week${weekNumber}`];
        if (!milestone) return null;

        const evaluation = {
            weekNumber,
            metrics: {},
            overallProgress: 0,
            recommendations: []
        };

        // 굴곡 평가
        const flexionProgress = (patientData.flexion / milestone.flexionGoal) * 100;
        evaluation.metrics.flexion = {
            current: patientData.flexion,
            goal: milestone.flexionGoal,
            progress: Math.min(flexionProgress, 100),
            status: this.getProgressStatus(flexionProgress)
        };

        // 보행 거리 평가
        const walkingProgress = (patientData.walkingDistance / milestone.walkingGoal) * 100;
        evaluation.metrics.walking = {
            current: patientData.walkingDistance,
            goal: milestone.walkingGoal,
            progress: Math.min(walkingProgress, 100),
            status: this.getProgressStatus(walkingProgress)
        };

        // 통증 평가
        const painProgress = ((10 - patientData.painLevel) / (10 - milestone.painTarget)) * 100;
        evaluation.metrics.pain = {
            current: patientData.painLevel,
            target: milestone.painTarget,
            progress: Math.min(painProgress, 100),
            status: this.getPainStatus(patientData.painLevel, milestone.painTarget)
        };

        // 종합 진행률
        evaluation.overallProgress = (
            evaluation.metrics.flexion.progress * 0.4 +
            evaluation.metrics.walking.progress * 0.3 +
            evaluation.metrics.pain.progress * 0.3
        ).toFixed(0);

        // 권장 사항 생성
        evaluation.recommendations = this.generateRehabRecommendations(evaluation);

        return evaluation;
    }

    getProgressStatus(percentage) {
        if (percentage >= 100) return 'excellent';
        if (percentage >= 80) return 'good';
        if (percentage >= 60) return 'fair';
        return 'needs_attention';
    }

    // 재활 권장 사항
    generateRehabRecommendations(evaluation) {
        const recommendations = [];

        // 굴곡 부족 시
        if (evaluation.metrics.flexion.status === 'needs_attention') {
            recommendations.push({
                type: 'exercise',
                title: '무릎 굴곡 운동 강화',
                description: '벽 슬라이드 운동을 하루 3회, 회당 15분씩 수행하세요.',
                videoUrl: '/exercises/wall-slide-tkr',
                frequency: '1일 3회'
            });
        }

        // 보행 부족 시
        if (evaluation.metrics.walking.status === 'needs_attention') {
            recommendations.push({
                type: 'activity',
                title: '보행 훈련 증가',
                description: '실내 보행을 점진적으로 늘려주세요. 목표의 10%씩 증가.',
                tips: ['보조기구 사용 권장', '휴식을 자주 취하세요'],
                frequency: '하루 4-6회 분산'
            });
        }

        // 통증 지속 시
        if (evaluation.metrics.pain.status === 'needs_attention') {
            recommendations.push({
                type: 'consult',
                title: '통증 관리 상담 필요',
                description: '예상보다 통증이 지속됩니다. 담당 의료진과 상담하세요.',
                action: 'schedule_teleconsult',
                urgency: 'within_48h'
            });
        }

        return recommendations;
    }

    // 재활 운동 영상 가이드
    async getExerciseGuidance(exerciseType, patientProgress) {
        const exercise = await this.exerciseDB.get(exerciseType);

        return {
            id: exercise.id,
            name: exercise.name,
            description: exercise.description,
            videoUrl: exercise.videoUrl,
            duration: exercise.baseDuration,
            repetitions: this.adjustRepetitions(exercise, patientProgress),
            precautions: exercise.precautions,
            modifications: this.suggestModifications(exercise, patientProgress)
        };
    }
}

7.6.3 성과 지표