コンピュータビジョンによる状況認識¶

// リアルタイム映像監視による状況認識システム
interface VideoAnalysisResult {
  frameId: string;
  timestamp: Date;
  detectedObjects: DetectedObject[];
  recognizedActions: RecognizedAction[];
  anomalies: Anomaly[];
  sceneClassification: SceneClassification;
  riskAssessment: RiskAssessment;
}

interface DetectedObject {
  id: string;
  class: string;
  confidence: number;
  boundingBox: BoundingBox;
  trackingId?: string;
  attributes: ObjectAttributes;
}

interface RecognizedAction {
  actionType: string;
  confidence: number;
  duration: number;
  involvedObjects: string[];
  riskLevel: 'low' | 'medium' | 'high' | 'critical';
}

interface Anomaly {
  type: 'behavior' | 'object' | 'scene' | 'pattern';
  description: string;
  severity: number;
  location: BoundingBox;
  confidence: number;
}

class RealTimeVideoSurveillanceSystem {
  private videoStreams: Map<string, MediaStream> = new Map();
  private canvasElements: Map<string, HTMLCanvasElement> = new Map();
  private objectDetector: ObjectDetectionModel;
  private actionRecognizer: ActionRecognitionModel;
  private anomalyDetector: AnomalyDetectionModel;
  private trackingSystem: MultiObjectTracker;
  private alertSystem: AlertSystem;

  constructor() {
    this.initializeVisionModels();
    this.setupRealTimeProcessing();
  }

  private initializeVisionModels(): void {
    // YOLO v8 ベースの物体検出
    this.objectDetector = new YOLOv8Detector({
      modelPath: '/models/yolov8n.onnx',
      classNames: this.getSecurityRelevantClasses(),
      confidenceThreshold: 0.5,
      nmsThreshold: 0.4
    });

    // 3D CNN による行動認識
    this.actionRecognizer = new Action3DCNNModel({
      modelPath: '/models/action_recognition_3dcnn.onnx',
      frameSequenceLength: 16,
      actions: [
        'normal_walking', 'running', 'fighting', 'falling',
        'suspicious_behavior', 'crowd_gathering', 'vehicle_accident'
      ]
    });

    // オートエンコーダーベース異常検知
    this.anomalyDetector = new AutoencoderAnomalyDetector({
      modelPath: '/models/anomaly_detection_ae.onnx',
      reconstructionThreshold: 0.8,
      spatialAttention: true
    });

    // マルチオブジェクト追跡
    this.trackingSystem = new DeepSORTTracker({
      maxAge: 30,
      minHits: 3,
      iouThreshold: 0.3
    });
  }

  // 複数カメラからの映像監視開始
  async startMultiCameraSurveillance(
    cameraConfigs: CameraConfig[]
  ): Promise<Observable<CameraSurveillanceResult[]>> {
    const surveillanceStreams = await Promise.all(
      cameraConfigs.map(async (config) => {
        const stream = await this.initializeCameraStream(config);
        return this.analyzeCameraStream(config.cameraId, stream);
      })
    );

    // 複数カメラの結果を統合
    return combineLatest(surveillanceStreams).pipe(
      map(results => this.integrateCameraResults(results)),
      tap(integratedResults => this.processIntegratedResults(integratedResults)),
      share()
    );
  }

  // 個別カメラストリームの分析
  private analyzeCameraStream(
    cameraId: string,
    stream: MediaStream
  ): Observable<CameraSurveillanceResult> {
    return new Observable<CameraSurveillanceResult>(observer => {
      const video = document.createElement('video');
      const canvas = document.createElement('canvas');
      const context = canvas.getContext('2d')!;

      video.srcObject = stream;
      video.play();

      canvas.width = 640;
      canvas.height = 480;
      this.canvasElements.set(cameraId, canvas);

      let frameBuffer: ImageData[] = [];
      let frameCount = 0;

      // フレーム処理間隔（30 FPS）
      const frameInterval = setInterval(async () => {
        try {
          // フレーム取得
          context.drawImage(video, 0, 0, canvas.width, canvas.height);
          const imageData = context.getImageData(0, 0, canvas.width, canvas.height);

          frameBuffer.push(imageData);
          if (frameBuffer.length > 16) frameBuffer.shift();

          // 分析実行
          const analysisResult = await this.analyzeVideoFrame(
            cameraId,
            imageData,
            frameBuffer,
            frameCount++
          );

          observer.next({
            cameraId,
            result: analysisResult,
            frameNumber: frameCount
          });

        } catch (error) {
          observer.error(error);
        }
      }, 1000 / 30);

      return () => {
        clearInterval(frameInterval);
        video.srcObject = null;
        stream.getTracks().forEach(track => track.stop());
      };
    });
  }

  // フレーム分析の実行
  private async analyzeVideoFrame(
    cameraId: string,
    currentFrame: ImageData,
    frameBuffer: ImageData[],
    frameNumber: number
  ): Promise<VideoAnalysisResult> {
    // 並列で各種分析を実行
    const [objectDetectionResult, actionRecognitionResult, anomalyResult] = 
      await Promise.all([
        this.detectObjects(currentFrame),
        this.recognizeActions(frameBuffer),
        this.detectAnomalies(currentFrame, frameBuffer)
      ]);

    // オブジェクト追跡の更新
    const trackedObjects = await this.trackingSystem.update(
      objectDetectionResult.detections
    );

    // シーン分類
    const sceneClassification = await this.classifyScene(currentFrame);

    // リスク評価
    const riskAssessment = this.assessRisk({
      objects: trackedObjects,
      actions: actionRecognitionResult,
      anomalies: anomalyResult,
      scene: sceneClassification
    });

    return {
      frameId: `${cameraId}_${frameNumber}`,
      timestamp: new Date(),
      detectedObjects: trackedObjects,
      recognizedActions: actionRecognitionResult,
      anomalies: anomalyResult,
      sceneClassification,
      riskAssessment
    };
  }

  // 物体検出
  private async detectObjects(imageData: ImageData): Promise<ObjectDetectionResult> {
    // ImageData を tensor に変換
    const tensor = this.imageDataToTensor(imageData);

    // YOLO推論実行
    const detections = await this.objectDetector.detect(tensor);

    // 後処理（NMS適用、信頼度フィルタリング）
    const filteredDetections = this.postProcessDetections(detections);

    return {
      detections: filteredDetections.map(det => ({
        id: this.generateDetectionId(),
        class: det.className,
        confidence: det.confidence,
        boundingBox: det.boundingBox,
        attributes: this.extractObjectAttributes(det, imageData)
      })),
      processingTime: performance.now()
    };
  }

  // 行動認識
  private async recognizeActions(
    frameSequence: ImageData[]
  ): Promise<RecognizedAction[]> {
    if (frameSequence.length < 16) return [];

    // フレームシーケンスをテンソルに変換
    const sequenceTensor = this.frameSequenceToTensor(
      frameSequence.slice(-16)
    );

    // 3D CNN による行動分類
    const actionProbabilities = await this.actionRecognizer.predict(
      sequenceTensor
    );

    // 閾値を超える行動を抽出
    const recognizedActions = actionProbabilities
      .filter(action => action.confidence > 0.7)
      .map(action => ({
        actionType: action.className,
        confidence: action.confidence,
        duration: this.estimateActionDuration(action),
        involvedObjects: this.findInvolvedObjects(action),
        riskLevel: this.assessActionRisk(action.className)
      }));

    return recognizedActions;
  }

  // 異常検知
  private async detectAnomalies(
    currentFrame: ImageData,
    frameHistory: ImageData[]
  ): Promise<Anomaly[]> {
    const anomalies: Anomaly[] = [];

    // オートエンコーダーによる再構成異常検知
    const reconstructionError = await this.anomalyDetector.getReconstructionError(
      currentFrame
    );

    if (reconstructionError > this.anomalyDetector.threshold) {
      const anomalyRegions = await this.localizeAnomalies(
        currentFrame,
        reconstructionError
      );

      anomalies.push(...anomalyRegions.map(region => ({
        type: 'scene' as const,
        description: `異常なシーンパターンを検出`,
        severity: region.severity,
        location: region.boundingBox,
        confidence: region.confidence
      })));
    }

    // 時系列パターン異常検知
    if (frameHistory.length >= 10) {
      const temporalAnomalies = await this.detectTemporalAnomalies(
        frameHistory
      );
      anomalies.push(...temporalAnomalies);
    }

    return anomalies;
  }

  // 複数カメラ結果の統合
  private integrateCameraResults(
    cameraResults: CameraSurveillanceResult[]
  ): IntegratedSurveillanceResult {
    // カメラ間での物体対応付け
    const globalObjectMap = this.correlateObjectsAcrossCameras(cameraResults);

    // 全体的な状況評価
    const overallSituation = this.assessOverallSituation(cameraResults);

    // 重要イベントの統合
    const consolidatedEvents = this.consolidateEvents(cameraResults);

    // アラート生成
    const alerts = this.generateIntegratedAlerts(
      overallSituation,
      consolidatedEvents
    );

    return {
      timestamp: new Date(),
      cameraResults,
      globalObjectMap,
      overallSituation,
      consolidatedEvents,
      alerts
    };
  }

  // インタラクティブな映像検索
  async searchVideoByDescription(
    description: string,
    timeRange: TimeRange
  ): Promise<VideoSearchResult[]> {
    // 自然言語による検索クエリ解析
    const queryAnalysis = await this.analyzeSearchQuery(description);

    // 該当する映像セグメントの検索
    const candidateSegments = await this.findCandidateSegments(
      queryAnalysis,
      timeRange
    );

    // 類似度による順位付け
    const rankedResults = await this.rankSearchResults(
      candidateSegments,
      queryAnalysis
    );

    return rankedResults.map(segment => ({
      videoId: segment.videoId,
      startTime: segment.startTime,
      endTime: segment.endTime,
      relevanceScore: segment.score,
      matchedElements: segment.matches,
      thumbnail: segment.thumbnail
    }));
  }

  // リアルタイムアラート処理
  private processIntegratedResults(
    results: IntegratedSurveillanceResult
  ): void {
    // 高リスクアラートの即座の処理
    const criticalAlerts = results.alerts.filter(
      alert => alert.severity === 'critical'
    );

    if (criticalAlerts.length > 0) {
      this.alertSystem.triggerEmergencyResponse(criticalAlerts);
    }

    // 中程度のアラートの蓄積と分析
    const mediumAlerts = results.alerts.filter(
      alert => alert.severity === 'medium'
    );

    if (mediumAlerts.length > 0) {
      this.alertSystem.accumulateAndAnalyze(mediumAlerts);
    }

    // ログとデータベースへの記録
    this.recordSurveillanceData(results);
  }
}

// 結果インターフェース
interface CameraSurveillanceResult {
  cameraId: string;
  result: VideoAnalysisResult;
  frameNumber: number;
}

interface IntegratedSurveillanceResult {
  timestamp: Date;
  cameraResults: CameraSurveillanceResult[];
  globalObjectMap: GlobalObjectMap;
  overallSituation: OverallSituationAssessment;
  consolidatedEvents: ConsolidatedEvent[];
  alerts: Alert[];
}

interface VideoSearchResult {
  videoId: string;
  startTime: Date;
  endTime: Date;
  relevanceScore: number;
  matchedElements: MatchedElement[];
  thumbnail: string;
}

// 医療画像診断支援システム
interface MedicalImageAnalysisResult {
  imageId: string;
  modality: 'X-Ray' | 'CT' | 'MRI' | 'Ultrasound' | 'Mammography';
  findings: MedicalFinding[];
  overallAssessment: DiagnosticAssessment;
  confidenceScore: number;
  recommendations: ClinicalRecommendation[];
  explanation: DiagnosticExplanation;
}

interface MedicalFinding {
  findingType: string;
  location: AnatomicalLocation;
  severity: 'normal' | 'mild' | 'moderate' | 'severe';
  confidence: number;
  boundingBox?: BoundingBox;
  segmentationMask?: Uint8Array;
  measurements?: Measurement[];
}

interface DiagnosticAssessment {
  primaryDiagnosis: string;
  differentialDiagnoses: string[];
  urgencyLevel: 'routine' | 'urgent' | 'emergent';
  followUpRequired: boolean;
  comparisonWithPrior?: PriorComparison;
}

class MedicalImageDiagnosticSystem {
  private chestXRayModel: ChestXRayClassifier;
  private ctScanAnalyzer: CTScanAnalyzer;
  private mriAnalyzer: MRIAnalyzer;
  private segmentationModel: MedicalSegmentationModel;
  private explainabilityEngine: MedicalXAIEngine;
  private clinicalKnowledgeBase: ClinicalKnowledgeBase;

  constructor() {
    this.initializeMedicalModels();
  }

  private initializeMedicalModels(): void {
    // 胸部X線分析モデル（14種類の所見検出）
    this.chestXRayModel = new ChestXRayClassifier({
      modelPath: '/models/chestxray_densenet121.onnx',
      diseases: [
        'Atelectasis', 'Cardiomegaly', 'Effusion', 'Infiltration',
        'Mass', 'Nodule', 'Pneumonia', 'Pneumothorax',
        'Consolidation', 'Edema', 'Emphysema', 'Fibrosis',
        'Pleural_Thickening', 'Hernia'
      ],
      threshold: 0.5
    });

    // CT画像解析（3D CNN）
    this.ctScanAnalyzer = new CTScanAnalyzer({
      lungNodulesModel: '/models/lung_nodules_3dcnn.onnx',
      liverLesionsModel: '/models/liver_lesions_unet.onnx',
      brainTumorModel: '/models/brain_tumor_resnet3d.onnx'
    });

    // MRI解析
    this.mriAnalyzer = new MRIAnalyzer({
      brainMRIModel: '/models/brain_mri_segmentation.onnx',
      cardiacMRIModel: '/models/cardiac_mri_analysis.onnx'
    });

    // セグメンテーション（U-Net系）
    this.segmentationModel = new MedicalSegmentationModel({
      architecture: 'attention_unet',
      modelPath: '/models/medical_segmentation_aunet.onnx'
    });

    // 説明可能AI
    this.explainabilityEngine = new MedicalXAIEngine({
      gradcamEnabled: true,
      shapEnabled: true,
      attentionVisualization: true
    });

    // 臨床知識ベース
    this.clinicalKnowledgeBase = new ClinicalKnowledgeBase({
      diseaseOntology: '/knowledge/disease_ontology.json',
      clinicalGuidelines: '/knowledge/clinical_guidelines.json',
      drugInteractions: '/knowledge/drug_interactions.json'
    });
  }

  // 医療画像の包括的分析
  async analyzeMedicalImage(
    imageData: DICOMImageData,
    patientInfo: PatientInfo,
    clinicalContext: ClinicalContext
  ): Promise<MedicalImageAnalysisResult> {
    // DICOM メタデータの解析
    const dicomMetadata = this.parseDICOMMetadata(imageData);

    // 画像前処理（正規化、強調、ノイズ除去）
    const preprocessedImage = await this.preprocessMedicalImage(
      imageData,
      dicomMetadata.modality
    );

    // モダリティ別の専門分析
    const modalitySpecificAnalysis = await this.performModalitySpecificAnalysis(
      preprocessedImage,
      dicomMetadata.modality,
      patientInfo
    );

    // セグメンテーション実行
    const segmentationResult = await this.performMedicalSegmentation(
      preprocessedImage,
      dicomMetadata.modality
    );

    // 所見の統合と評価
    const consolidatedFindings = this.consolidateFindings(
      modalitySpecificAnalysis,
      segmentationResult
    );

    // 臨床的評価
    const clinicalAssessment = await this.performClinicalAssessment(
      consolidatedFindings,
      patientInfo,
      clinicalContext
    );

    // 説明可能性の生成
    const explanation = await this.generateDiagnosticExplanation(
      preprocessedImage,
      consolidatedFindings,
      clinicalAssessment
    );

    return {
      imageId: imageData.instanceUID,
      modality: dicomMetadata.modality,
      findings: consolidatedFindings,
      overallAssessment: clinicalAssessment,
      confidenceScore: this.calculateOverallConfidence(consolidatedFindings),
      recommendations: this.generateClinicalRecommendations(clinicalAssessment),
      explanation: explanation
    };
  }

  // モダリティ別専門分析
  private async performModalitySpecificAnalysis(
    image: ProcessedMedicalImage,
    modality: string,
    patientInfo: PatientInfo
  ): Promise<ModalitySpecificResult> {
    switch (modality) {
      case 'X-Ray':
        return await this.analyzeChestXRay(image, patientInfo);

      case 'CT':
        return await this.analyzeCTScan(image, patientInfo);

      case 'MRI':
        return await this.analyzeMRIScan(image, patientInfo);

      case 'Ultrasound':
        return await this.analyzeUltrasound(image, patientInfo);

      default:
        throw new Error(`Unsupported modality: ${modality}`);
    }
  }

  // 胸部X線解析
  private async analyzeChestXRay(
    image: ProcessedMedicalImage,
    patientInfo: PatientInfo
  ): Promise<ChestXRayAnalysisResult> {
    // 14疾患の同時検出
    const diseaseClassification = await this.chestXRayModel.classify(image);

    // 解剖学的構造の検出
    const anatomicalStructures = await this.detectAnatomicalStructures(
      image,
      'chest'
    );

    // 心胸郭比の計算
    const cardiothoracicRatio = this.calculateCardiothoracicRatio(
      anatomicalStructures
    );

    // 年齢・性別を考慮した正常値との比較
    const ageGenderAdjustedAssessment = this.adjustForPatientDemographics(
      diseaseClassification,
      patientInfo
    );

    return {
      diseaseClassifications: ageGenderAdjustedAssessment,
      anatomicalStructures: anatomicalStructures,
      measurements: {
        cardiothoracicRatio: cardiothoracicRatio,
        lungVolume: this.estimateLungVolume(anatomicalStructures)
      },
      qualityAssessment: this.assessImageQuality(image)
    };
  }

  // CT画像解析
  private async analyzeCTScan(
    image: ProcessedMedicalImage,
    patientInfo: PatientInfo
  ): Promise<CTAnalysisResult> {
    // 3Dボリューム解析
    const volumeAnalysis = await this.ctScanAnalyzer.analyzeVolume(image);

    // 臓器別分析
    const organSpecificAnalysis = await this.performOrganSpecificCTAnalysis(
      image,
      volumeAnalysis.detectedOrgans
    );

    // 造影剤効果の分析（造影CT の場合）
    let contrastAnalysis = null;
    if (this.isContrastEnhanced(image)) {
      contrastAnalysis = await this.analyzeContrastEnhancement(image);
    }

    return {
      volumeAnalysis: volumeAnalysis,
      organAnalysis: organSpecificAnalysis,
      contrastAnalysis: contrastAnalysis,
      reconstructionMetrics: this.calculateReconstructionMetrics(image)
    };
  }

  // 診断説明の生成
  private async generateDiagnosticExplanation(
    image: ProcessedMedicalImage,
    findings: MedicalFinding[],
    assessment: DiagnosticAssessment
  ): Promise<DiagnosticExplanation> {
    // Grad-CAM による注意領域の可視化
    const attentionMaps = await this.explainabilityEngine.generateGradCAM(
      image,
      findings
    );

    // SHAP値による特徴量重要度
    const featureImportance = await this.explainabilityEngine.calculateSHAP(
      image,
      assessment.primaryDiagnosis
    );

    // 自然言語での説明生成
    const naturalLanguageExplanation = this.generateNaturalLanguageExplanation(
      findings,
      assessment,
      attentionMaps
    );

    // 類似症例の検索
    const similarCases = await this.findSimilarCases(
      findings,
      assessment.primaryDiagnosis
    );

    return {
      attentionMaps: attentionMaps,
      featureImportance: featureImportance,
      explanation: naturalLanguageExplanation,
      similarCases: similarCases,
      confidence: this.calculateExplanationConfidence(
        attentionMaps,
        featureImportance
      )
    };
  }

  // 時系列医療画像の比較分析
  async compareMedicalImageSeries(
    currentImage: DICOMImageData,
    priorImages: DICOMImageData[],
    patientInfo: PatientInfo
  ): Promise<MedicalImageSeriesComparison> {
    // 各画像の個別分析
    const currentAnalysis = await this.analyzeMedicalImage(
      currentImage,
      patientInfo,
      { type: 'follow_up' }
    );

    const priorAnalyses = await Promise.all(
      priorImages.map(image => 
        this.analyzeMedicalImage(image, patientInfo, { type: 'prior' })
      )
    );

    // 時系列変化の分析
    const progressionAnalysis = this.analyzeProgression(
      currentAnalysis,
      priorAnalyses
    );

    // 治療効果の評価
    const treatmentResponse = this.evaluateTreatmentResponse(
      progressionAnalysis,
      patientInfo.treatmentHistory
    );

    return {
      currentAnalysis: currentAnalysis,
      priorAnalyses: priorAnalyses,
      progressionAnalysis: progressionAnalysis,
      treatmentResponse: treatmentResponse,
      clinicalSignificance: this.assessClinicalSignificance(
        progressionAnalysis
      )
    };
  }

  // AI診断品質保証
  async performQualityAssurance(
    analysisResult: MedicalImageAnalysisResult,
    groundTruth?: GroundTruthData
  ): Promise<QualityAssuranceReport> {
    // 信頼度の検証
    const confidenceValidation = this.validateConfidenceScores(
      analysisResult
    );

    // 一貫性チェック
    const consistencyCheck = this.checkDiagnosticConsistency(
      analysisResult
    );

    // 既知の限界との照合
    const limitationAssessment = this.assessKnownLimitations(
      analysisResult
    );

    // グラウンドトゥルースとの比較（利用可能な場合）
    let performanceMetrics = null;
    if (groundTruth) {
      performanceMetrics = this.calculatePerformanceMetrics(
        analysisResult,
        groundTruth
      );
    }

    return {
      confidenceValidation: confidenceValidation,
      consistencyCheck: consistencyCheck,
      limitationAssessment: limitationAssessment,
      performanceMetrics: performanceMetrics,
      overallQualityScore: this.calculateOverallQualityScore({
        confidenceValidation,
        consistencyCheck,
        limitationAssessment
      })
    };
  }
}

// 結果インターフェース
interface DiagnosticExplanation {
  attentionMaps: AttentionMap[];
  featureImportance: FeatureImportanceMap;
  explanation: string;
  similarCases: SimilarCase[];
  confidence: number;
}

interface MedicalImageSeriesComparison {
  currentAnalysis: MedicalImageAnalysisResult;
  priorAnalyses: MedicalImageAnalysisResult[];
  progressionAnalysis: ProgressionAnalysis;
  treatmentResponse: TreatmentResponseEvaluation;
  clinicalSignificance: ClinicalSignificanceAssessment;
}