顔特徴量:顔の映像から眠気・集中・緊張・情動の変化を読み取る
プログラムの動作の様子の動画:[動画]
実行ファイル:[exe]
実行ファイル(exe)は、Chrome または Firefox を用いてダウンロードすることを推奨。初回実行時に、SmartScreenの「WindowsによってPCが保護されました」の警告画面が出ます。警告画面で「詳細情報」をクリック、「実行」をクリックで続行できます。
コード内で使用しているソフトのライセンス文と著作権表示: LICENSE.txt, LICENSE-3RD-PARTY.txt
説明資料: [PDF], [PPTX], [動画](クリックして再生開始), クレジット:動画は「VOICEVOX:青山龍星」、「Vrew」、「Gemini」を用いて作成
概要:このプログラムは、カメラまたは動画ファイルに映る顔の映像から、眠気・集中・緊張・陽性情動の4つの状態が数十秒から数時間の間にどのように変化しているかを推定します。推定の結果は、根拠となる特徴量の推移とともに画面にリアルタイムで表示されます。
プログラムの理念と目的
本プログラムは、カメラの前で作業や学習をしている利用者の顔映像から、数十秒から数時間のスパンで以下の4つの状態の変化を推定します。
- 眠気・疲労:閉眼率、長い瞬目、欠伸の頻度、頭部の下垂などから推定。
- 集中・意欲:視線や顔向きの逸脱、頭部の運動量、カメラからの距離などから推定。
- 緊張・精神負荷:皺眉、眼瞼の緊張、口唇の圧迫、心拍数などから推定。
- 陽性情動:口角や頬の挙上などから推定。
各状態の推定は、計測開始直後の校正期間(既定30秒)に記録した利用者本人の普段の値(個人基準)との比較に基づいています。個人基準からの偏差(σ)で評価することで、目の大きさや普段の表情といった個人差の影響を最小限に抑え、安定したフィードバックを提供します。
ユーザーが自分自身の状態の変化を客観的に認識し、休憩や対応策を判断できるよう支援することが目標です。推定結果とその根拠となる特徴量の推移は画面にリアルタイムで表示され、眠気が高い水準に達した場合は警告表示や警告音で知らせ、休憩や仮眠を促します。
注:本プログラムが示す推定結果や助言はすべて参考値であり、利用者の実際の状態と必ずしも一致するとは限りません。
特徴量
本プログラムは26種類の特徴量を4つのカテゴリーに分類して算出しています。
1. 覚醒・眠気(8項目)
- 閉眼率 PERCLOS (%):閉眼度が0.80以上のフレームの割合。
- 開瞼度 (%):1から閉眼度を引いた値。
- 瞬目率 (回/分):直近30秒の瞬目の回数を1分当たりに換算。
- 瞬目持続時間 (ms):直近30秒の瞬目の持続時間の中央値。
- 長い瞬目(≥400ms)(回/分):持続時間が400ミリ秒以上の瞬目の頻度。
- 欠伸の頻度 (回/分):直近120秒の欠伸の回数を1分当たりに換算。
- 下方視の傾向:目が下を向く度合い(0〜1)。
- 顔面の微細な動き (%/秒):頭部の動きを除いた眉、まぶた、唇、頬の特徴点の移動量。
2. 表情・情動(7項目)
以下の項目は表情係数から求める0〜1の値です。
- 眉の挙上:眉の内側や外側を上げる動き。
- 皺眉(眉の下制):眉を下げる動き。
- 眼瞼の緊張:目を細める動き。
- 頬の挙上:頬を上げる動き。
- 口角の挙上(微笑み):口角を上げる動き。
- 口唇の圧迫:唇を押し付ける、または口角を下げる動き。
- 開口度:口を開ける動き。
3. 頭部・視線・姿勢(8項目)
- 頭部ピッチ (度):頭部の上下方向の角度(上向きが正)。
- 頭部ヨーの偏り (度):個人基準との差の絶対値。
- 頭部ロールの偏り (度):個人基準との差の絶対値。
- 頭部の運動量 (度/秒):直前フレームからの頭部の回転角。
- 頭部の微振動 (度):ヨー角とピッチ角の指数移動平均との差の絶対値の合計。
- 頭の位置の沈み込み:画面内での頭の上下位置(値が大きいほど低い)。
- カメラからの距離(相対):変換行列の平行移動成分の大きさ。
- 視線の逸脱 (%):視線や頭部の向きが個人基準の判定幅を超えたフレームの割合。
4. 生体・計測品質(3項目)
- 心拍数 (bpm):顔の色の変化から推定した参考値。
- 計測品質:顔の明るさ、大きさ、向きを合成した指標(0〜1)。
- 顔の検出率 (%):解析に使えたフレームの割合。
機能概要
計測の流れは以下のステップで構成されます。
1. 起動設定
起動設定画面で、映像ソース(カメラ、動画ファイル、デモ動画)と以下の計測条件を選択します。
- 個人基準の校正時間(20、30、45、60、90秒から選択。既定は30秒)
- rPPGによる心拍推定の有無
- 眠気警告音の有無
- 映像の左右反転(表示だけの反転。解析には影響しない)
- カメラの露出指数(カメラ選択時。既定は「フレームレートに合わせる」。−3〜−9の数値も選択可)
カメラを選んだ場合、計測開始時に、実際にフレームを取得してカメラの撮影モードを実測し、フレームレートが高いことを優先し、そのうえで解像度が最も高いものを選びます。フレームレート300、120、60、30 fpsの順に、それぞれ解像度1920×1080、1280×720、640×480の順に試します(1920×1080を超える解像度は用いません)。実測の進み具合は起動設定画面に表示されます。
カメラの自動露出は、暗いと露光時間を延ばしてフレームレートを下げるため用いず、露出を固定します。露出を固定できるのはDirectShowだけなので、カメラはDirectShowで開きます(DirectShowで開けない場合だけMedia Foundationで開き、そのときの露出はカメラ側の設定のままです)。露出指数xの露光時間はおよそ2x秒です。「フレームレートに合わせる」では、実測したフレームレートの1フレーム間隔に収まる最長の露光時間とし、設定後に実測し直して、フレームレートが下がれば1段ずつ短くします。
2. 顔の検出
MediaPipeを使用して顔を検出します。検出結果として478点の顔特徴点の3次元座標、52種類の表情係数、顔の位置と向きを表す変換行列が得られます。外眼角間距離が画像幅の1.25%未満の顔は解析対象外となります。
3. 特徴量の算出
顔特徴点、表情係数、変換行列から、26種類の特徴量を算出します。
4. 瞬目と欠伸の検出
閉眼度と開口度に基づいて瞬き(瞬目)とあくび(欠伸)を判定します。
5. 心拍数の推定(rPPG)
有効設定時のみ、顔の色の変化からPOS法を用いて心拍数を推定します。信頼度が低い推定値は使用されません。
6. 1秒ごとの集約
計測品質が0.35以上のフレームのみを使用し、1秒ごとに各特徴量の中央値(割合量は平均値)を求めます。最大7200個(2時間分)のデータが保持されます。
7. 個人基準の校正
計測開始後、設定した校正時間(既定30秒)の間に個人基準を確立します。その間に得られた各特徴量の中央値を個人基準とし、中央値絶対偏差(MAD)をばらつきとして記録します。以後の値は個人基準との差をばらつきで割ったσで表現されます。
頭部ヨーの偏り、頭部ロールの偏り、視線の逸脱は、校正期間中はその時点までの暫定の基準で求めているため、校正の完了時に、確定した基準と判定幅で計算し直してから個人基準を求めます。
8. 現在値・σ・傾きの算出
以下の値を1秒ごとに計算します。
- 現在値:直近60秒の中央値(割合量は平均値)。
- σ(シグマ):現在値と個人基準との差をばらつきで割った値。±4の範囲に収められます。
- 傾き:直近180秒の値からTheil-Sen回帰で求め、1分当たりの変化量に換算。
- τ(タウ):Kendallの順位相関係数で、変化の向きの一貫性を表します。+0.30以上で上昇傾向、−0.30以下で低下傾向、それ以外で横ばいと判定されます。
9. 総合指標と水準の判定
校正完了後、4つの総合指標(眠気・疲労、集中・意欲、緊張・精神負荷、陽性情動)を1秒ごとに算出します。各指標は構成特徴量のσに重みを掛けて足し合わせた重み付き平均で、時定数15秒の指数平滑化で滑らかにされます。水準の判定に際しては、境界値付近での頻繁な切り替わりを防ぐために0.15の幅(ヒステリシス)が設けられ、新しい水準が20秒以上続いた場合にのみ切り替わります。
10. フィードバック表示
計測画面に以下の情報が表示されます。
- 総合指標の現在値と傾向
- 寄与度の高い特徴量と根拠
- 状態に応じた助言
- 眠気が高い水準の場合は警告メッセージと警告音
11. 記録の保存と終了
計測終了時に以下の4つのファイルが「記録」フォルダに保存されます。
- レポート(txt):セッションの要約、統計値、所見
- 計測値(CSV):1秒ごとの全特徴量と総合指標
- 計測画面の画像(PNG):終了直前の画面キャプチャ
- まとめ画面(PNG):セッション全体の推移をまとめたグラフ
総合指標の定義
各総合指標は、構成する特徴量のσに重みを掛けて足し合わせ、重みの絶対値の合計で割った重み付き平均です。重みが正(+)の特徴量は値が上がると総合指標を上昇させ、重みが負(−)の特徴量は値が上がると総合指標を低下させます。z値が得られた成分の重みの絶対値合計が、全特徴量の重みの絶対値合計の60%未満の場合は算出されません。水準の境界値は−0.60、+0.60、+1.40です。
| 総合指標 | 構成特徴量と重み | 水準(低い順) |
|---|---|---|
| 眠気・疲労 |
閉眼率 +0.24、長い瞬目 +0.16、瞬目持続時間 +0.12、開瞼度 −0.12、欠伸の頻度 +0.12、頭部ピッチ −0.08、頭の位置の沈み込み +0.06、顔面の微細な動き −0.06、下方視の傾向 +0.04
|
低い/平常/やや高い/高い |
| 集中・意欲 |
視線が逸れた割合 −0.24、閉眼率 −0.20、頭部ヨーの偏り −0.16、頭部の運動量 −0.12、カメラからの距離 −0.10、瞬目率 −0.10、眉の挙上 +0.08
|
低下/平常/良好/高い |
| 緊張・精神負荷 |
皺眉 +0.22、眼瞼の緊張 +0.18、口唇の圧迫 +0.16、瞬目率 +0.14、頭部の微振動 +0.12、心拍数 +0.10、口角の挙上 −0.08
|
低い/平常/やや高い/高い |
| 陽性情動 |
口角の挙上 +0.34、頬の挙上 +0.24、眉の挙上 +0.14、皺眉 −0.16、口唇の圧迫 −0.12
|
乏しい/平常/良好/高い |
計測画面の構成
計測画面は左右2列に構成されています。
左列
- 映像パネル(上):ライブ映像に、顔のランドマーク、頭部の向きを示す3本の矢印、rPPG解析用の領域を重ねて表示。上端にカメラの実測フレームレート・解像度・方式(DS = DirectShow、MF = Media Foundation。開始時の実測値)・露出指数(Media Foundationの場合は「機器設定」)、処理のフレームレート、計測品質、rPPGとグラフ・表の更新の入・切を表示(動画ファイルでは公称フレームレートと解像度)。下部に閉眼度、頭部の回転角を表示。
- セッション全体のトレンド(中):計測開始からの4つの総合指標の推移を折れ線グラフで表示。イベント(瞬き、欠伸、状態遷移など)の時刻に印がつきます。
- イベント・状態遷移の記録(下):直近のイベントを時系列で表示。ボタン(ヘルプ、目印、保存、再校正)があります。
右列
- ヘッダー(最上部):プログラム名、経過時間、FPS、計測品質、顔の検出率、心拍数を表示。2行目には校正状況、再生速度(動画時)、一時停止状態、警告音の有無を表示。
- いまの状態:4つの総合指標の水準と傾向、注目すべき指標の根拠、助言を表示。
- 総合指標:各指標の値(棒グラフ)、水準、傾き、τ、寄与度の高い特徴量3つを表示。
- 所見:変化の目立つ特徴量を最大5件、個人基準と現在値、σ、傾き、τを表示。
- 特徴量の詳細:4つのタブで26種類の特徴量を表で表示。各行に現在値、個人基準、σ、基準からの偏差(棒グラフ)、傾き、τ、直近4分間の推移グラフを表示。
キー操作(計測画面)
| キー | 機能 |
|---|---|
Q または ESC |
計測を終了。記録を保存し、まとめ画面を表示。 |
C |
個人基準を取り直す。 |
P または TAB |
特徴量の詳細の表を次のページに切り替える。 |
1〜4 |
特徴量の詳細の表を指定したページに切り替える。 |
Space |
映像の解析を一時停止/再開。 |
M |
映像の表示の左右反転のオン/オフを切り替える(解析には影響しない)。 |
R |
rPPGによる心拍推定のオン/オフを切り替える(負荷の大きい処理)。 |
G |
計測画面のグラフ・表(映像パネル以外)の更新のオン/オフを切り替える(負荷の大きい処理。切っても特徴量の算出と記録は続く)。 |
F |
動画ファイルの再生速度を切り替える(1倍、2倍、4倍)。カメラ入力では無効。 |
E |
現在の時刻に目印をつける。 |
S |
その時点の記録を保存。 |
A |
眠気の警告音のオン/オフを切り替える。 |
H |
ヘルプの表示と非表示を切り替える。 |
マウスの左クリックで、タブ、ページ、ボタンを操作できます。ウィンドウの閉じるボタンで閉じた場合も計測は終了し、記録は保存されますが、まとめ画面は表示されません。
使用技術
顔認識と特徴抽出
MediaPipe Tasks Face Landmarker:Googleが提供する顔認識機能を使用します。モデルファイル(face_landmarker.task)には、顔検出モデル(BlazeFace short-range)、478点の顔特徴点を出力するモデル(FaceMesh-V2)、52種類の表情係数を出力するモデルが含まれています。このファイルは初回計測開始時にダウンロードされ、プログラムと同じフォルダの「assets」フォルダに保存されます。
眠気・姿勢の判定
- EAR(Eye Aspect Ratio):目の周囲の6点から求める目の縦横比。頭部の向きによる見かけの短縮を避けるため、特徴点の3次元座標を頭部の前額面に投影して求めます。目を閉じると値が小さくなります。
- PERCLOS:閉眼度が0.80以上のフレームの割合。本プログラムでは、閉眼度が0.80以上のフレームの割合で近似します。
統計手法
- 中央値絶対偏差(MAD):各値と中央値との差の絶対値について、その中央値をとった値。外れ値の影響を受けにくいばらつきの尺度です。
- Theil-Sen回帰:2点間の傾きをすべての組について求め、その中央値を傾きとする回帰手法。外れ値の影響を受けにくい。
- Kendallの順位相関係数τ:2つの量の順序がどれだけ一致しているかを−1〜+1で表します。本プログラムでは、時刻と値の順序の一致度を、変化の向きの一貫性として用います。
- POS法(rPPG):顔の色の変化から肌の色と直交する平面に射影して脈波成分を取り出し、心拍数を推定する方法。
- 指数平滑化とヒステリシス:総合指標は時定数15秒の指数平滑化で滑らかにされます。水準判定には0.15の幅(ヒステリシス)が設けられ、新しい水準が20秒以上続いた場合にのみ切り替わります。
実行上の注意点
セットアップと動作環境
- OS:本プログラムはWindows専用です。
- ネットワーク接続:初回計測開始時にモデルファイル(約1MB)とデモ動画(約15MB)をインターネットからダウンロードします。ダウンロードに失敗した場合は、ネットワーク接続を確認した後、プログラムを再起動してください。
- Python環境:Python 3.12、numpy、mediapipe、opencv-contrib-python、pillow が必要です。
計測条件
- 校正期間:計測開始後の設定時間(既定30秒)を校正期間とします。この間は普段どおりの姿勢で正面を向いて過ごしてください。校正期間中にすでに眠かった場合などは、その状態が「平常」とみなされます。座る位置、照明、カメラの位置が変わった場合は、Cキーを押して個人基準を取り直してください。
- 顔の映りこみ:解析する顔は1つのみです。複数の人が映らない環境で使用してください。両目尻の間の距離が画像幅の1.25%未満の顔は解析されません。計測品質が0.35未満のフレームは1秒ごとの集約から除かれます。顔の検出率が低い場合は、カメラを顔の正面に置き、顔が大きく明るく映るよう距離と照明を調整してください。
機能の制限
- 心拍数:照明の変化や体の動きの影響を受ける参考値です。頭部の動きが多い区間と信頼度の低い推定値は自動的に除外されるため、心拍数が「−−」と表示されることがあります。心拍数が不要な場合は、起動設定画面の「rPPG による心拍推定を行う」をオフにしてください。計測中はRキーで入り切りできます。
- データ保持期間:1秒ごとの特徴量と総合指標の推移は直近2時間分のみが保持されます。計測が2時間を超える場合は、定期的にSキーで記録を保存してください。イベント記録は直近500件までです。
プライバシーと同意
- データの処理:MediaPipeは入力された映像を端末内で処理し、Googleのサーバーには送信しません。ただし、利用状況に関するメトリクスはGoogleに送信される可能性があります。本プログラムの利用では、この点を事前に利用者に説明し、同意を得てください。
- 保存ファイル:「画面_日時.png」には利用者の顔の画像が含まれます。顔の画像を含めずに記録を他の人に渡す場合は、レポート(txt)と計測値(csv)のみを渡してください。
トラブルシューティング
- カメラが開けない:起動設定画面でカメラ番号を変更するか、他のアプリケーションがカメラを使用していないか確認してください。
- 動画ファイルが開けない:mp4(H.264)形式の動画を使用してください。
- 画像が暗い:照明を明るくしてください。露出指数を大きくすると明るくなりますが、露光時間が1フレーム間隔を超えるとフレームレートが下がります。
- 処理のフレームレートが低い:RキーでrPPGを、Gキーでグラフ・表の更新を切ると、処理のフレームレートが上がります。
exeファイルの作成手順
cd /d c:\users\user\proj\facefeature
python -m venv venv
venv\Scripts\activate.bat
python -m pip install --upgrade pip
pip install -U --no-user pyinstaller pytest numpy mediapipe opencv-contrib-python pillow
pyinstaller --onefile --clean --noconfirm --collect-all numpy --collect-all mediapipe --collect-all opencv-contrib-python --collect-all PIL facefeature.py
実行ファイル:[exe]
実行ファイル(exe)は、Chrome または Firefox を用いてダウンロードすることを推奨。初回実行時に、SmartScreenの「WindowsによってPCが保護されました」の警告画面が出ます。警告画面で「詳細情報」をクリック、「実行」をクリックで続行できます。
コード内で使用しているソフトのライセンス文と著作権表示: LICENSE.txt, LICENSE-3RD-PARTY.txt
ソースコード実行のための前準備
Python 3.12 のインストール
Pythonのインストールを行い、Pythonのプログラムを実行する環境を整える。扱う環境は、Windows搭載パソコンである。金子研究室では、Python 3.12.10を推奨する。
[Windows での Python 3.12 のインストール手順を見るには、ここをクリック]
Windows での Python 3.12 のインストール
以下のいずれかの方法でPython 3.12をインストールする。Pythonがインストール済みの場合、この手順は不要である。
方法 1:winget によるインストール
【インストールコマンドの実行方法】
管理者権限でコマンドプロンプトを起動する(手順:Windowsキーまたはスタートメニュー → cmd と入力 → 右クリック → 「管理者として実行」)。そして、コマンド全体をコマンドプロンプトにコピー&ペーストする。
--scope machine を指定することで、システム全体(全ユーザー向け)にインストールされる。このオプションの実行には管理者権限が必要である。インストール完了後、コマンドプロンプトを再起動するとPATHが反映される。
REM Python 3.12 をシステム領域にインストール
winget install --id Python.Python.3.12 -e --scope machine --silent --accept-source-agreements --accept-package-agreements --override "/quiet InstallAllUsers=1 PrependPath=1 Include_test=0 Include_pip=1 Include_launcher=1 InstallLauncherAllUsers=1 TargetDir=\"C:\Program Files\Python312\""
if not "%ERRORLEVEL%"=="0" ( color 0c & echo Python 3.12 のインストールに失敗しました & ping 127.0.0.1 -n 6 >nul & color )
REM Python と Scripts を PATH 先頭に追加
powershell -NoProfile -Command "$p='C:\Program Files\Python312'; $s=\"$p\Scripts\"; if(Test-Path $p){$k=[Microsoft.Win32.Registry]::LocalMachine.OpenSubKey('SYSTEM\CurrentControlSet\Control\Session Manager\Environment',$true); $c=$k.GetValue('Path','',[Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames); $t=$k.GetValueKind('Path'); $new=$c; if((';'+$new+';') -notlike \"*;$p;*\"){$new=$p+';'+$new}; if((';'+$new+';') -notlike \"*;$s;*\"){$new=$s+';'+$new}; if($new -ne $c){$k.SetValue('Path',$new,$t)}; $k.Close()}"
REM 現在のセッションにも反映(システムPATHを再取得して連結)
for /f "usebackq tokens=2,*" %A in (`reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v Path`) do set "PATH=%B"
REM pip / wheel の更新
python -m pip install --no-user -U pip wheel
if not "%ERRORLEVEL%"=="0" ( color 0c & echo pip / wheel の更新に失敗しました & ping 127.0.0.1 -n 6 >nul & color )
方法 2:インストーラーによるインストール
- Python公式サイト(https://www.python.org/downloads/)にアクセスし、「Download Python 3.x.x」ボタンからWindows用インストーラーをダウンロードする。
- ダウンロードしたインストーラーを実行する。
- 初期画面の下部に表示される「Add python.exe to PATH」にチェックを入れてから「Customize installation」を選択する。このチェックを入れ忘れると、コマンドプロンプトから
pythonコマンドを実行できない。 - 「Install Python 3.xx for all users」にチェックを入れ、「Install」をクリックする。
インストールの確認
コマンドプロンプトで以下を実行する。
python --version
バージョン番号(例:Python 3.12.x)が表示されればインストール成功である。「'python' は、内部コマンドまたは外部コマンドとして認識されていません。」と表示される場合は、インストールが正常に完了していない。
Python の開発環境 Visual Studio Code のインストールと Python 用の設定
Python の開発環境Visual Studio Code(プログラムを編集するソフトウェア。以下、VS Code)を整える。
[Windows での Visual Studio Code のインストールと Python 用の設定手順を見るには、ここをクリック]
Windows での Visual Studio Code のインストールと Python 用の設定手順
1. VS Code と拡張機能のインストール
以下のコマンドにより,既存の VS Code を削除し,全ユーザー共有の設定で再インストールしたうえで,拡張機能(VS Code に機能を追加するソフトウェア)をまとめて導入する.
【インストールコマンドの実行方法】
管理者権限でコマンドプロンプトを起動する(手順:Windows キーまたはスタートメニュー → cmd と入力 → 右クリック → 「管理者として実行」)。そして,コマンド全体をコマンドプロンプトにコピー&ペーストする。
インストールコマンド
REM ============================================================
REM Microsoft Visual Studio Code
REM ============================================================
REM Build Tools + Desktop development with C++(VCTools)+ 追加コンポーネント(一括)
REM 未インストール時: winget で新規インストール
REM インストール済み時: setup.exe modify でコンポーネント追加(バージョンは変更しない)
winget list --id Microsoft.VisualStudio.BuildTools 2>nul | findstr /i "BuildTools" >nul 2>&1
if %ERRORLEVEL% EQU 0 (
for /f "usebackq delims=" %P in (`"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" -products Microsoft.VisualStudio.Product.BuildTools -property installationPath`) do start /wait "" "C:\Program Files (x86)\Microsoft Visual Studio\Installer\setup.exe" modify --installPath "%P" --add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Workload.MSBuildTools --add Microsoft.VisualStudio.Component.VC.CMake.Project --add Microsoft.VisualStudio.Component.VC.Llvm.Clang --add Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset --add Microsoft.VisualStudio.Component.Windows11SDK.26100 --add Microsoft.VisualStudio.Component.VC.v143.x86.x64 --includeRecommended --quiet --norestart --nocache
if not "%ERRORLEVEL%"=="0" ( color 0c & echo Build Tools のコンポーネント追加に失敗しました & ping 127.0.0.1 -n 6 >nul & color )
) else (
winget install --scope machine --id Microsoft.VisualStudio.BuildTools -e --silent --disable-interactivity --force --accept-source-agreements --accept-package-agreements --override "--quiet --wait --norestart --nocache --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --add Microsoft.VisualStudio.Workload.MSBuildTools --add Microsoft.VisualStudio.Component.VC.CMake.Project --add Microsoft.VisualStudio.Component.VC.Llvm.Clang --add Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset --add Microsoft.VisualStudio.Component.Windows11SDK.26100 --add Microsoft.VisualStudio.Component.VC.v143.x86.x64"
if not "%ERRORLEVEL%"=="0" ( color 0c & echo Build Tools のインストールに失敗しました & ping 127.0.0.1 -n 6 >nul & color )
)
REM 全ユーザー共有の拡張機能フォルダ
if not exist "C:\ProgramData\vscode-extensions" mkdir "C:\ProgramData\vscode-extensions"
icacls "C:\ProgramData\vscode-extensions" /grant "Everyone:(OI)(CI)M" /T
REM スタートメニューのショートカットを --extensions-dir 付きで再作成
if exist "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code" rmdir /s /q "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code"
if exist "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk" del "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk"
powershell -NoProfile -Command "$s=New-Object -ComObject WScript.Shell; $lnk=$s.CreateShortcut('C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk'); $lnk.TargetPath='C:\Program Files\Microsoft VS Code\Code.exe'; $lnk.Arguments='--extensions-dir \"C:\ProgramData\vscode-extensions\"'; $lnk.Save()"
REM ショートカットの検証
powershell -NoProfile -Command "$s=New-Object -ComObject WScript.Shell; $lnk=$s.CreateShortcut('C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk'); Write-Host 'TargetPath:' $lnk.TargetPath; Write-Host 'Arguments:' $lnk.Arguments"
REM ファイル / フォルダ右クリックの「Code で開く」を登録
reg add "HKLM\SOFTWARE\Classes\*\shell\VSCode\command" /ve /d "\"C:\Program Files\Microsoft VS Code\Code.exe\" --extensions-dir \"C:\ProgramData\vscode-extensions\" \"%1\"" /f
reg add "HKLM\SOFTWARE\Classes\Directory\shell\VSCode\command" /ve /d "\"C:\Program Files\Microsoft VS Code\Code.exe\" --extensions-dir \"C:\ProgramData\vscode-extensions\" \"%1\"" /f
reg add "HKLM\SOFTWARE\Classes\Directory\Background\shell\VSCode\command" /ve /d "\"C:\Program Files\Microsoft VS Code\Code.exe\" --extensions-dir \"C:\ProgramData\vscode-extensions\" \"%V\"" /f
REM --extensions-dir 付きで起動する code.cmd ラッパを作成
REM (%* を echo で書くと対話的 cmd で失われるため、PowerShell で [char]37+'*' を書き出す)
powershell -NoProfile -Command "$pct=[char]37; $q=[char]34; $c='@echo off'+[char]13+[char]10+$q+'C:\Program Files\Microsoft VS Code\bin\code.cmd'+$q+' --extensions-dir '+$q+'C:\ProgramData\vscode-extensions'+$q+' '+$pct+'*'+[char]13+[char]10; [IO.File]::WriteAllText('C:\ProgramData\vscode-extensions\vscode.cmd',$c,[Text.Encoding]::ASCII)"
REM 拡張機能のインストール
set "CODE=C:\Program Files\Microsoft VS Code\bin\code.cmd"
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --uninstall-extension GitHub.copilot
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --uninstall-extension GitHub.copilot-chat
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension ms-python.python
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension ms-python.vscode-pylance
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension ms-python.debugpy
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension MS-CEINTL.vscode-language-pack-ja
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension saoudrizwan.claude-dev
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension rust-lang.rust-analyzer
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension tamasfe.even-better-toml
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension anthropic.claude-code
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension almenon.arepl
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --list-extensions --show-versions
REM settings.json を作成(自動更新オフ、Python、Claude Code 設定)
if not exist "%APPDATA%\Code\User" mkdir "%APPDATA%\Code\User"
python -c "import json,os;data={'update.mode':'none','update.enableWindowsBackgroundUpdates':False,'extensions.autoUpdate':False,'python.defaultInterpreterPath':r'C:\Program Files\Python312\python.exe','claudeCode.environmentVariables':[{'name':'ANTHROPIC_API_KEY','value':'not-needed'},{'name':'ANTHROPIC_AUTH_TOKEN','value':'ollama'},{'name':'ANTHROPIC_BASE_URL','value':'http://localhost:11434'},{'name':'ANTHROPIC_MODEL','value':'glm-4.7-flash'},{'name':'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC','value':'1'}]};p=os.path.join(os.environ['APPDATA'],'Code','User','settings.json');open(p,'w',encoding='utf-8').write(json.dumps(data,indent=4));print('Done:',p)"
REM 自動更新の抑止ポリシー(settings.json に加えて、レジストリ側でも明示的にオフ)
reg add "HKLM\SOFTWARE\Policies\Microsoft\VSCode" /v "UpdateMode" /t REG_SZ /d "none" /f
echo === セットアップ完了 ===
2. Python インタプリタの選択
同一マシンに複数の Python がインストールされている場合,VS Code で使用する Python 本体(インタプリタ:Python プログラムを解釈・実行するソフトウェア)を選択する必要がある.
- コマンドパレット(コマンド名で機能を呼び出す VS Code の入力欄)を開く(
Ctrl+Shift+P) Python: Select Interpreterと入力する
- 表示される一覧から,使用する Python(例:
C:\Program Files\Python312\python.exe)を選択する.
必要なライブラリをシステム領域にインストール
管理者権限でコマンドプロンプトを起動する
(手順:Windowsキーまたはスタートメニュー → cmd と入力 → 右クリック → 「管理者として実行」)。
以下を実行する。
REM インストール
pip uninstall -y opencv-python-headless opencv-contrib-python-headless opencv-python
pip install -U --no-user numpy mediapipe opencv-contrib-python pillow
ソースコード
# -*- coding: utf-8 -*-
"""
顔特徴トレンド・モニタ(MediaPipe Tasks API/Windows 専用)
================================================================================
カメラまたは動画に映る顔から、数十秒から数時間の時間尺度で、次の4つの総合指標が
「個人基準からどれだけ変化したか」を求め、根拠となる特徴量の推移とともに表示する。
・眠気関連(PERCLOS(P80)・長い瞬目・あくび・頭部の下垂 など)
・注視関連(視線・顔向きの逸脱・頭部の角速度・カメラからの距離 など)
・緊張関連(眉の下制・眼瞼の緊張・口唇の圧迫・頭部の微小動揺・脈拍数 など)
・笑顔関連(口角の挙上・頬の挙上・眉の挙上 など)
総合指標は、各特徴量のロバスト z 値を、経験的に定めた重み(妥当性は未検証)で平均した
「目安」である。眠気・注意・緊張・情動といった心理状態を測定した値ではない。
外れ値に頑健な多段処理
フレーム値 → 1秒ごとの中央値(1秒値) → 直近60秒の中央値(現在値)
→ 直近180秒の Theil–Sen 推定量(傾き)と Kendall の τb(単調性の記述統計量)
(1秒値が90個以上そろった場合のみ算出する)
→ ヒステリシスと20秒の継続条件による水準判定
ロバスト z 値は「(現在値 − 個人基準の中央値) ÷ max(1.4826 × MAD, 下限)」で定義する。
MAD は校正期間の1秒値の中央絶対偏差であり、下限は特徴量ごとに定める。
必要ライブラリ: pip install mediapipe opencv-contrib-python numpy pillow
モデルとデモ動画は、このファイルと同じ場所の assets フォルダへ自動で取得する。
MediaPipe Tasks の Python 版は Windows で GPU デリゲートに対応しないため、
GPU を搭載した機械でも推論は CPU で行う。
本プログラムは医療機器ではない。表示値はすべて参考値である。
================================================================================
"""
from __future__ import annotations
import csv
import ctypes
import math
import os
# Media Foundation でカメラを開く際の、ハードウェア変換に起因する起動遅延を避ける。
# cv2 の読み込みより前に設定する必要がある。
os.environ.setdefault("OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS", "0")
import time
import tkinter as tk
import unicodedata
import urllib.request
import winsound
from collections import deque
from dataclasses import dataclass, field
from tkinter import filedialog, font as tkfont, ttk
from typing import Any, Deque, Dict, List, Optional, Sequence, Tuple
import cv2
import mediapipe as mp
import numpy as np
from mediapipe.tasks import python as mp_tasks
from mediapipe.tasks.python import vision as mp_vision
from numpy.lib.stride_tricks import sliding_window_view
from PIL import Image, ImageDraw, ImageFont
# ==============================================================================
# 0. 配置・定数
# ==============================================================================
APP_DIR = os.path.dirname(os.path.abspath(__file__))
ASSET_DIR = os.path.join(APP_DIR, "assets")
RECORD_DIR = os.path.join(APP_DIR, "記録")
FONT_DIR = os.path.join(os.environ["WINDIR"], "Fonts")
# 日本語フォント。日本語版以外の Windows ではメイリオが入っていないことがあるため、
# 存在するものを順に探す(メイリオ → 游ゴシック → MS ゴシック)。
FONT_PATH = next((p for p in (os.path.join(FONT_DIR, n)
for n in ("meiryo.ttc", "YuGothM.ttc", "msgothic.ttc"))
if os.path.exists(p)), os.path.join(FONT_DIR, "meiryo.ttc"))
# 公式ドキュメントが案内するモデルバンドル(顔検出・FaceMesh-V2・ブレンドシェイプ)
MODEL_URL = ("https://storage.googleapis.com/mediapipe-models/face_landmarker/"
"face_landmarker/float16/latest/face_landmarker.task")
MODEL_PATH = os.path.join(ASSET_DIR, "face_landmarker.task")
MODEL_MIN_BYTES = 1_000_000
# デモ動画: Intel IoT DevKit の公開サンプル(正面顔・頭部の向きの変化を含む/約15MB)
DEMO_URL = ("https://raw.githubusercontent.com/intel-iot-devkit/sample-videos/"
"master/head-pose-face-detection-female.mp4")
DEMO_PATH = os.path.join(ASSET_DIR, "demo_face.mp4")
DEMO_MIN_BYTES = 10_000_000
ANALYZE_W = 1280 # 解析に用いる画像の最大横幅[画素](超える場合は縮小)
VIEW_W, VIEW_H = 640, 480 # 映像パネルの大きさ
CANVAS_W, CANVAS_H = 1600, 860 # 計測画面全体の大きさ
TICK_SEC = 1.0 # 1秒値の集約単位[秒]
WIN_NOW = 60.0 # 現在値の窓[秒]
WIN_TREND = 180.0 # 傾き推定の窓[秒]
TREND_MIN_TICKS = 90 # 傾き・τ の算出に必要な1秒値の個数(90秒分)
SPARK_SEC = 240.0 # 表の推移グラフの表示長[秒]
DWELL_SEC = 20.0 # 水準の切り替えに必要な継続時間[秒]
INDEX_TAU = 15.0 # 総合指標の指数平滑化の時定数[秒]
WIN_BLINK = 30.0 # 瞬目を数える窓[秒]
WIN_YAWN = 120.0 # あくびを数える窓[秒]
HIST_TICKS = 7200 # 保持する1秒値の個数(2時間分)
QUALITY_MIN = 0.35 # 解析に用いるフレームの画像品質スコアの下限
ALERT_INTERVAL = 120.0 # 眠気関連指標の警告を繰り返す最短間隔[秒]
LONG_BLINK = 0.40 # 長い瞬目とみなす持続時間[秒]
SMOOTH_TICKS = 15 # 割合量の推移の表示と傾き推定に用いる移動平均の幅[1秒値の個数]
# 視線の逸脱の判定幅(ブレンドシェイプ係数の差の大きさ)。校正期間の視線のばらつきから決め、
# 下限と上限で制限する。校正が完了するまでは既定値を用いる。
GAZE_OFF_DEFAULT = 0.34
GAZE_OFF_MIN, GAZE_OFF_MAX = 0.26, 0.52
GAZE_OFF_GAIN = 1.8 # 校正期間の偏差の90パーセンタイルに掛ける倍率
YAW_OFF_DEG = 25.0 # 逸脱と判定する、個人基準からの頭部ヨー角の差[度]
INDEX_MIN_WEIGHT = 0.60 # 総合指標の算出に必要な、z が得られた成分の重みの割合
# 文字の大きさ[画素]。目盛りだけ 13、本文は 14 以上とする。
FS_TICK, FS_BODY, FS_LABEL, FS_TITLE = 13, 14, 15, 16
NAN = float("nan")
# ------------------------------------------------------------------------------
# 特徴点番号(FaceLandmarker v2/478点)
# ------------------------------------------------------------------------------
LM_R_EYE = [33, 160, 158, 133, 153, 144] # EAR(眼の縦横比)用
LM_L_EYE = [362, 385, 387, 263, 373, 380]
LM_IOD = (33, 263) # 外眼角間距離
LM_MOUTH_V = (13, 14)
LM_MOUTH_H = (61, 291)
ANCHOR_IDX = [1, 4, 6, 168, 33, 133, 362, 263, 234, 454, 10, 151, 93, 323]
EXPR_IDX = [70, 63, 105, 66, 107, 336, 296, 334, 293, 300,
159, 145, 386, 374, 158, 153, 385, 380,
61, 291, 13, 14, 78, 308, 0, 17, 84, 314, 37, 267, 405, 181,
205, 425, 118, 347]
DRAW_CONTOURS = [
[33, 160, 158, 133, 153, 144, 33],
[362, 385, 387, 263, 373, 380, 362],
[70, 63, 105, 66, 107],
[336, 296, 334, 293, 300],
[61, 37, 0, 267, 291, 405, 17, 181, 61],
[78, 13, 308, 14, 78],
[10, 234, 152, 454, 10],
]
# ------------------------------------------------------------------------------
# 配色(BGR)
# ------------------------------------------------------------------------------
C_BG = (26, 24, 22)
C_PANEL = (44, 41, 38)
C_PANEL2 = (56, 52, 48)
C_ROW = (50, 47, 44)
C_LINE = (82, 78, 74)
C_BTN = (72, 68, 64)
C_TXT = (234, 234, 234)
C_DIM = (160, 158, 156)
C_ACC = (235, 185, 95)
C_OK = (120, 215, 130)
C_WARN = (70, 190, 250)
C_BAD = (95, 100, 250)
C_UP = (110, 205, 245)
C_DOWN = (215, 165, 100)
C_PLOT = (34, 32, 30)
C_CALIB = (48, 45, 42)
C_BAND = (66, 60, 50)
# ==============================================================================
# 1. 特徴量と総合指標の定義
# ==============================================================================
@dataclass(frozen=True)
class MetricSpec:
key: str
name: str
unit: str
page: int
hint: str = "" # 定義と値の変化の解釈(表に添える短い説明)
scale: float = 1.0 # 内部単位から表示単位への倍率
fmt: str = "{:.2f}"
floor_abs: float = 0.02 # z の分母の下限(絶対値・内部単位)
floor_rel: float = 0.0 # z の分母の下限(個人基準の値に対する比)
analyze: bool = True # 傾き推定と総合指標の対象とするか
agg: str = "median" # 窓内の代表値("median"、割合量は "mean")
@property
def label(self) -> str:
"""記録ファイルの列名(表示単位つき)。"""
return f"{self.name}[{self.unit}]" if self.unit else self.name
METRICS: List[MetricSpec] = [
# ---- ページ1: 眠気関連 ---------------------------------------------------
MetricSpec("perclos", "PERCLOS(P80)", "%", 0,
"閉眼度0.8以上の時間割合。上昇は眠気と関連", 100, "{:.1f}", 0.020, agg="mean"),
MetricSpec("eye_open", "開瞼度", "%", 0, "1−閉眼度。低下は眠気と関連", 100, "{:.1f}", 0.015),
MetricSpec("blink_rate", "瞬目頻度", "回/分", 0, "30秒窓。疲労・認知負荷・発話で変動", 1,
"{:.1f}", 1.5),
MetricSpec("blink_dur", "瞬目持続時間", "ms", 0, "閉眼度50%交差間の中央値。延長は眠気と関連",
1000, "{:.0f}", 0.015),
MetricSpec("long_blink_rate", "長い瞬目の頻度", "回/分", 0, "持続400ms以上。上昇は眠気と関連",
1, "{:.2f}", 0.35),
MetricSpec("yawn_rate", "あくびの頻度", "回/分", 0, "120秒窓。上昇は眠気と関連", 1,
"{:.2f}", 0.22),
MetricSpec("gaze_down", "下方視", "", 0, "eyeLookDown 係数(0〜1)。手元を見ても上昇", 1,
"{:.3f}", 0.030),
MetricSpec("inner_motion", "顔面内部の運動量", "%/秒", 0,
"頭部運動除去後の特徴点速度(外眼角間距離比)", 1, "{:.2f}", 0.25),
# ---- ページ2: 表情(ブレンドシェイプ係数 0〜1。AU は FACS への近似的な対応) --
MetricSpec("brow_up", "眉の挙上", "", 1, "AU1+AU2 に近似(係数 0〜1)", 1, "{:.3f}", 0.025),
MetricSpec("brow_down", "眉の下制", "", 1, "AU4 に近似(係数 0〜1)", 1, "{:.3f}", 0.025),
MetricSpec("squint", "眼瞼の緊張", "", 1, "AU7 に近似(係数 0〜1)", 1, "{:.3f}", 0.025),
MetricSpec("cheek_raise", "頬の挙上", "", 1, "AU6 に近似(係数 0〜1)", 1, "{:.3f}", 0.020),
MetricSpec("smile", "口角の挙上", "", 1, "AU12 に近似(係数 0〜1)", 1, "{:.3f}", 0.020),
MetricSpec("mouth_press", "口唇の圧迫", "", 1, "AU24+AU15 に近似(係数 0〜1)", 1,
"{:.3f}", 0.025),
MetricSpec("jaw_open", "開口度", "", 1, "発話・あくびで上昇(0〜1)", 1, "{:.3f}", 0.020),
# ---- ページ3: 頭部・視線・姿勢 -------------------------------------------
MetricSpec("pitch", "頭部ピッチ角", "度", 2, "上を向くと正", 1, "{:+.1f}", 1.5),
MetricSpec("yaw_dev", "頭部ヨー角の偏差", "度", 2, "個人基準の向きとの差の絶対値", 1,
"{:.1f}", 1.5),
MetricSpec("roll_dev", "頭部ロール角の偏差", "度", 2, "個人基準の傾きとの差の絶対値", 1,
"{:.1f}", 1.2),
MetricSpec("head_speed", "頭部の角速度", "度/秒", 2, "フレーム間の回転角÷時間", 1,
"{:.2f}", 0.50),
MetricSpec("jitter", "頭部の微小動揺", "度", 2, "ヨー・ピッチ角の0.6秒EMAからの偏差和", 1,
"{:.3f}", 0.030),
MetricSpec("head_drop", "眼の画像内高さ", "画像高比", 2, "下方へ移ると上昇", 1,
"{:.3f}", 0.0, 0.03),
MetricSpec("dist", "カメラからの距離", "相対値", 2, "変換行列の並進の大きさ。離れると上昇",
1, "{:.1f}", 0.0, 0.02),
MetricSpec("gaze_off_rate", "視線・顔向きの逸脱率", "%", 2, "判定幅を超えたフレームの割合",
100, "{:.1f}", 0.030, agg="mean"),
# ---- ページ4: rPPG(参考)・計測品質 -------------------------------------
MetricSpec("hr", "脈拍数(rPPG)", "bpm", 3, "POS法による推定値。照明・体動の影響を受ける",
1, "{:.1f}", 3.0),
MetricSpec("hr_conf", "rPPGスペクトル集中度", "", 3, "基本波・第2高調波近傍のパワー比(0〜1)",
1, "{:.2f}", 0.05, 0.0, False),
MetricSpec("quality", "画像品質スコア", "", 3, "輝度・顔の大きさ・ヨー角の重み付き和(0〜1)",
1, "{:.2f}", 0.05, 0.0, False),
MetricSpec("coverage", "有効フレーム率", "%", 3, "画像品質スコア0.35以上のフレームの割合",
100, "{:.0f}", 0.05, 0.0, False, agg="mean"),
]
METRIC_MAP: Dict[str, MetricSpec] = {m.key: m for m in METRICS}
PAGE_TITLES = ["眠気関連", "表情", "頭部・視線・姿勢", "rPPG(参考)・計測品質"]
N_PAGES = len(PAGE_TITLES)
PAGE_METRICS = [[m for m in METRICS if m.page == p] for p in range(N_PAGES)]
TAB_TITLES = ["所見と根拠", "総合指標の内訳", "時系列グラフ", "特徴量の表"]
N_TABS = len(TAB_TITLES)
# フレームごとに保持する値と、1秒ごとに中央値をとる値
FRAME_KEYS = ("eye_open", "perclos_flag", "gaze_down", "inner_motion",
"brow_up", "brow_down", "squint", "cheek_raise", "smile",
"mouth_press", "jaw_open", "pitch", "yaw", "roll", "head_speed",
"jitter", "head_drop", "dist", "quality", "gaze_h", "gaze_v")
MEDIAN_KEYS = ("eye_open", "gaze_down", "inner_motion", "brow_up", "brow_down",
"squint", "cheek_raise", "smile", "mouth_press", "jaw_open",
"pitch", "head_speed", "jitter", "head_drop", "dist", "quality",
"hr", "hr_conf")
# 個人基準の向き(中央値)を必要とする量。逸脱の判定はこの基準との差で行う。
REF_KEYS = ("yaw", "roll", "gaze_h", "gaze_v")
# 映像の左右反転で符号が反転する量
MIRROR_KEYS = ("yaw", "roll", "gaze_h")
LEVELS = ("低い", "基準付近", "やや高い", "高い")
LEVEL_EDGES = (-0.60, 0.60, 1.40)
LEVEL_HYST = 0.15
@dataclass(frozen=True)
class IndexSpec:
key: str
name: str
comps: Tuple[Tuple[str, float], ...]
higher_is_good: bool
color: Tuple[int, int, int]
advice: str
INDEXES: List[IndexSpec] = [
IndexSpec("drowsy", "眠気関連", (
("perclos", +0.24), ("long_blink_rate", +0.16), ("blink_dur", +0.12),
("eye_open", -0.12), ("yawn_rate", +0.12), ("pitch", -0.08),
("head_drop", +0.06), ("inner_motion", -0.06), ("gaze_down", +0.04)),
False, (95, 100, 250),
"休憩・換気を検討してください(照明の変化・下方視・眼鏡の反射でも上昇します)。"),
IndexSpec("focus", "注視関連", (
("gaze_off_rate", -0.24), ("perclos", -0.20), ("yaw_dev", -0.16),
("head_speed", -0.12), ("dist", -0.10), ("blink_rate", -0.10),
("brow_up", +0.08)),
True, (120, 215, 130),
"視線・顔向きが個人基準から逸れる時間が増えています(資料や手元を見る作業でも低下します)。"),
IndexSpec("tension", "緊張関連", (
("brow_down", +0.22), ("squint", +0.18), ("mouth_press", +0.16),
("blink_rate", +0.14), ("jitter", +0.12), ("hr", +0.10),
("smile", -0.08)),
False, (70, 190, 250),
"眉・眼瞼・口唇の係数が基準より大きい状態です。肩の力を抜き、息を長く吐いてみてください。"),
IndexSpec("positive", "笑顔関連", (
("smile", +0.34), ("cheek_raise", +0.24), ("brow_up", +0.14),
("brow_down", -0.16), ("mouth_press", -0.12)),
True, (235, 185, 95),
"口角・頬の挙上(AU12・AU6 に近似)が個人基準より大きい状態です。"),
]
INDEX_MAP: Dict[str, IndexSpec] = {i.key: i for i in INDEXES}
INDEX_KEYS = {key for spec in INDEXES for key, _ in spec.comps}
INDEX_TOTAL_W = {spec.key: sum(abs(w) for _, w in spec.comps) for spec in INDEXES}
# ヘルプの内容(節の見出し、(項目名, 説明) の並び)。起動設定画面と計測画面のヘルプで共用する。
HELP_SECTIONS: List[Tuple[str, List[Tuple[str, str]]]] = [
("用語と数値の定義", [
("1秒値", "1秒間のフレーム値の中央値。PERCLOS・逸脱率・有効フレーム率は平均。"),
("個人基準", "校正期間の1秒値の中央値(割合量は平均)。ばらつきは MAD(中央絶対偏差)で表す。"),
("ロバスト z", "(現在値 − 個人基準) ÷ max(1.4826×MAD, 下限)。±4 で打ち切る。"
"1.4826×MAD は正規分布のもとで標準偏差の一致推定量となる。下限は特徴量ごとに定める。"),
("現在値", "直近60秒の1秒値の中央値(割合量は平均)。"),
("傾き・τb", "直近180秒の Theil–Sen 推定量(1分当たり)と、時刻と値の Kendall 順位相関係数 τb。"
"1秒値が90個以上ある場合だけ求める。1秒値は自己相関が強いため、"
"τb は記述統計量であり、有意性の検定には使えない。"),
("総合指標", "Σ w·clip(z, ±3) ÷ Σ|w| を時定数15秒で指数平滑化した値(0=個人基準)。"
"重み w は経験的に定めた未検証の値。心理状態の測定値ではなく、"
"照明・姿勢・発話・眼鏡の反射でも変化する。"),
("水準", "境界 −0.6/+0.6/+1.4 に ±0.15 のヒステリシスを設け、"
"新しい水準が20秒続いたら切り替える。"),
]),
("操作(キー/画面上のボタン)", [
("Q/ESC", "終了(記録を保存し、まとめを表示)"),
("C", "個人基準の取り直し"),
("T", "右下のタブの切り替え"),
("P/TAB", "ページ送り(1〜4 のキーでページを直接指定)"),
("SPACE", "一時停止・再開"),
("M", "映像の左右反転の切り替え"),
("F", "再生速度の切り替え(動画のみ)"),
("E", "目印をつける"),
("S", "途中保存"),
("A", "警告音の入・切"),
("H", "ヘルプの表示・非表示"),
]),
("記録", [
("保存先", "プログラムと同じ場所の「記録」フォルダ(終了時と S キーで保存)"),
("内容", "レポート(txt)・1秒値(csv、表示単位)・計測画面(png)・まとめ(png)"),
("注意", "計測画面の png には顔画像が含まれる"),
]),
]
HELP_LABEL_W = 104 # 計測画面のヘルプで、項目名の列に割り当てる幅[画素]
# ==============================================================================
# 2. 汎用の関数
# ==============================================================================
def isnum(v: Any) -> bool:
"""数値であり NaN でないかを判定する。"""
return isinstance(v, (int, float)) and not math.isnan(float(v))
def clamp(v: float, lo: float, hi: float) -> float:
return lo if v < lo else (hi if v > hi else v)
def median_of(values: Sequence[float]) -> float:
vals = [v for v in values if isnum(v)]
return float(np.median(vals)) if vals else NAN
def mad_of(values: Sequence[float], med: float) -> float:
"""中央絶対偏差(一致性の係数 1.4826 を掛ける前の値)。"""
vals = [v for v in values if isnum(v)]
return float(np.median(np.abs(np.asarray(vals) - med))) if vals else NAN
def rolling_mean(values: np.ndarray, width: int) -> np.ndarray:
"""後方移動平均。先頭は最初の値で埋めて長さを保つ。"""
if values.size < 3:
return values
k = min(width, values.size)
padded = np.concatenate([np.full(k - 1, values[0]), values])
return np.convolve(padded, np.ones(k) / k, mode="valid")
_PAIR_CACHE: Dict[int, Tuple[np.ndarray, np.ndarray]] = {}
def _pairs(n: int) -> Tuple[np.ndarray, np.ndarray]:
"""全ての組 (i<j) の添字(個数ごとに再利用する)。"""
if n not in _PAIR_CACHE:
_PAIR_CACHE[n] = np.triu_indices(n, 1)
return _PAIR_CACHE[n]
def trend_of(ts: np.ndarray, vs: np.ndarray) -> Tuple[float, float]:
"""傾き[単位/分](Theil–Sen 推定量)と Kendall の τb を返す。
1秒値が TREND_MIN_TICKS 個に満たない場合は求めない。移動窓で作った1秒値は
隣接値が強く相関するため、短い区間では τ が見かけ上大きくなるからである。
時刻は狭義単調増加で同順位がないので、τb = S ÷ √(n0 × 値に同順位のない組の数)
(S は値の差の符号の総和、n0 は全組数)となる。回数から作る量は同順位が多く、
τa では絶対値が過小になるため τb を用いる。全ての値が等しい場合は順位相関が
定義されないため、単調傾向なし(0)として扱う。
窓は最長181点なので、全ての組(最大16290組)を厳密に評価する。
"""
if vs.size < TREND_MIN_TICKS:
return NAN, NAN
i, j = _pairs(vs.size)
dv = vs[j] - vs[i]
sgn = np.sign(dv)
untied = int(np.count_nonzero(sgn))
tau = float(sgn.sum()) / math.sqrt(sgn.size * untied) if untied else 0.0
return float(np.median(dv / (ts[j] - ts[i]))) * 60.0, tau
def sigma_scale(spec: MetricSpec, mad: float, base: float) -> float:
"""z の分母(1.4826×MAD。特徴量ごとの下限を必ず適用する)。"""
return max(1.4826 * (mad if isnum(mad) else 0.0),
spec.floor_abs,
spec.floor_rel * abs(base) if isnum(base) else 0.0,
1e-6)
def pad_display(text: str, width: int) -> str:
"""全角文字を2桁と数えて左詰めする(レポートの桁揃え用)。"""
disp = sum(2 if unicodedata.east_asian_width(ch) in "WFA" else 1 for ch in text)
return text + " " * max(width - disp, 0)
def decimals_of(fmt: str) -> int:
"""書式文字列から小数点以下の桁数を取り出す。"""
return int(fmt.split(".")[1][0]) if "." in fmt else 0
def fmt_value(spec: MetricSpec, raw: float) -> str:
return spec.fmt.format(raw * spec.scale) if isnum(raw) else "--"
def fmt_slope(spec: MetricSpec, raw: float) -> str:
if not isnum(raw):
return "--"
return ("{:+." + str(decimals_of(spec.fmt)) + "f}").format(raw * spec.scale)
def slope_unit(spec: MetricSpec) -> str:
"""傾きの単位(例: (回/分)/分、%/分)。"""
if not spec.unit:
return "/分"
return f"({spec.unit})/分" if "/" in spec.unit else f"{spec.unit}/分"
def fmt_clock(t: float) -> str:
return f"{int(t // 60):02d}:{int(t % 60):02d}"
def trend_arrow(tau: float) -> str:
if not isnum(tau):
return "→"
return "↗" if tau >= 0.30 else ("↘" if tau <= -0.30 else "→")
def change_word(delta: float, eps: float) -> str:
"""変化量を言葉にする(まとめ・レポート用)。"""
if not isnum(delta) or abs(delta) < eps:
return "ほぼ横ばい"
return "上昇" if delta > 0 else "低下"
def index_color(spec: IndexSpec, value: float) -> Tuple[int, int, int]:
"""総合指標の値に応じた配色(計測画面とまとめ画面で共通)。"""
if not isnum(value):
return C_DIM
if spec.higher_is_good:
return C_BAD if value < -0.60 else (C_DIM if value < 0.60 else C_OK)
return C_OK if value < 0.60 else (C_WARN if value < 1.40 else C_BAD)
def nice_ticks(lo: float, hi: float, target: int) -> Tuple[List[float], int]:
"""lo〜hi に収まる 1・2・5×10^k 刻みの目盛りと、表示する小数桁数を返す。"""
raw = (hi - lo) / max(target, 1)
mag = 10.0 ** math.floor(math.log10(raw))
step = next(k * mag for k in (1.0, 2.0, 5.0, 10.0) if raw <= k * mag * (1 + 1e-9))
first = math.ceil(lo / step - 1e-9) * step
count = int((hi - first) / step + 1e-9) + 1
dec = max(0, -int(math.floor(math.log10(step) + 1e-9)))
return [round(first + i * step, dec + 2) + 0.0 for i in range(count)], dec
TIME_STEPS = (5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600, 7200)
def time_ticks(t0: float, t1: float, max_n: int) -> List[float]:
"""時刻目盛り(切りのよい秒数の倍数)を返す。"""
step = next((s for s in TIME_STEPS if (t1 - t0) / s <= max_n), TIME_STEPS[-1])
first = math.ceil(t0 / step) * step
return [first + i * step for i in range(int((t1 - first) / step) + 1)]
def fill_box(img: np.ndarray, x0: int, y0: int, x1: int, y1: int,
fill: Tuple[int, int, int], edge: Tuple[int, int, int] = C_LINE) -> None:
"""塗りつぶした矩形に1画素の枠を描く。"""
cv2.rectangle(img, (x0, y0), (x1, y1), fill, -1)
cv2.rectangle(img, (x0, y0), (x1, y1), edge, 1)
def tint_rows(img: np.ndarray, y0: int, y1: int, color: Tuple[int, int, int],
alpha: float) -> np.ndarray:
"""画像の y0〜y1 の帯に、指定色を不透明度 alpha で重ねる。"""
band = img.copy()
cv2.rectangle(band, (0, y0), (img.shape[1], y1), color, -1)
return cv2.addWeighted(band, alpha, img, 1.0 - alpha, 0)
@dataclass(frozen=True)
class ViewMap:
"""解析画像の座標を、映像パネルの座標へ移す写像。"""
scale: float
ox: int
oy: int
def pt(self, x: float, y: float) -> Tuple[int, int]:
return int(round(x * self.scale)) + self.ox, int(round(y * self.scale)) + self.oy
def letterbox(img: np.ndarray, w: int, h: int) -> Tuple[np.ndarray, ViewMap]:
"""縦横比を保って所定の大きさへ収め、座標の写像も返す。"""
ih, iw = img.shape[:2]
s = min(w / iw, h / ih)
nw, nh = max(1, int(round(iw * s))), max(1, int(round(ih * s)))
out = np.zeros((h, w, 3), np.uint8)
ox, oy = (w - nw) // 2, (h - nh) // 2
out[oy:oy + nh, ox:ox + nw] = (img if (nw, nh) == (iw, ih) else
cv2.resize(img, (nw, nh), interpolation=cv2.INTER_AREA))
return out, ViewMap(s, ox, oy)
def shrink_to_width(img: np.ndarray, target: int) -> np.ndarray:
"""横幅が target を超える場合だけ、縦横比を保って縮小する。"""
h, w = img.shape[:2]
if w <= target:
return img
return cv2.resize(img, (target, max(1, int(round(h * target / w)))),
interpolation=cv2.INTER_AREA)
def save_image(path: str, img: np.ndarray) -> None:
"""日本語を含むパスへ PNG を書き出す(cv2.imwrite は非ASCIIパスを扱えない)。"""
cv2.imencode(".png", img)[1].tofile(path)
def short_path(path: str) -> str:
"""8.3 形式のパスに変換する(VideoCapture は非ASCIIパスを開けないため)。"""
buf = ctypes.create_unicode_buffer(1024)
n = ctypes.windll.kernel32.GetShortPathNameW(path, buf, 1024)
return buf.value if 0 < n < 1024 else path
def window_geometry() -> Tuple[int, int, int, int]:
"""画面の解像度から、はみ出さないウィンドウの大きさと位置を決める。"""
user32 = ctypes.windll.user32
sw, sh = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
s = min(1.0, 0.96 * sw / CANVAS_W, 0.88 * sh / CANVAS_H)
w, h = int(CANVAS_W * s), int(CANVAS_H * s)
return w, h, max(0, (sw - w) // 2), max(0, (sh - h) // 2 - 24)
# ==============================================================================
# 3. 文字の描画(日本語)
# ==============================================================================
PIL_ANCHOR = {"lt": "la", "lm": "lm", "rt": "ra", "rm": "rm", "ct": "ma", "cm": "mm"}
class TextLayer:
"""1枚分の文字をためておき、PIL への変換1回でまとめて描画する。"""
def __init__(self, font_path: str):
self.font_path = font_path
self._fonts: Dict[int, ImageFont.FreeTypeFont] = {}
self._items: List[Tuple[int, int, str, int, Tuple[int, int, int], str]] = []
def add(self, x: int, y: int, text: str, size: int = FS_LABEL,
color: Tuple[int, int, int] = C_TXT, anchor: str = "lt") -> None:
"""anchor: 1文字目 l/c/r(水平方向)、2文字目 m なら垂直方向の中央。"""
if text:
self._items.append((int(x), int(y), str(text), int(size), color, anchor))
def font(self, size: int) -> ImageFont.FreeTypeFont:
if size not in self._fonts:
self._fonts[size] = ImageFont.truetype(self.font_path, size)
return self._fonts[size]
def width(self, text: str, size: int) -> int:
return int(self.font(size).getlength(text))
def fit(self, text: str, size: int, max_px: int) -> str:
"""1行に収まるよう末尾を省略する。"""
if self.width(text, size) <= max_px:
return text
while text and self.width(text + "…", size) > max_px:
text = text[:-1]
return text + "…"
# 行頭に置かない文字(行頭禁則)
KINSOKU_HEAD = "、。,.)」』】・:;?!ー…%"
def wrap(self, text: str, size: int, max_px: int, max_lines: int = 2) -> List[str]:
"""指定の幅で折り返す。英数字の語の途中では切らず、行頭禁則文字は前の文字と一緒に送る。
行数を超える分は末尾を省略する。"""
lines, cur = [], ""
for ch in text:
if cur and self.width(cur + ch, size) > max_px:
cut = len(cur)
if ch in self.KINSOKU_HEAD:
cut -= 1
elif ch.isascii() and ch.isalnum():
k = cut
while k > 0 and cur[k - 1].isascii() and cur[k - 1].isalnum():
k -= 1
if k > 0:
cut = k
if cut <= 0:
cut = len(cur)
lines.append(cur[:cut].rstrip())
cur = cur[cut:].lstrip() + ch
else:
cur += ch
lines.append(cur)
if len(lines) > max_lines:
lines = lines[:max_lines]
lines[-1] = self.fit(lines[-1] + "……", size, max_px)
return lines
def flush(self, img: np.ndarray) -> np.ndarray:
if not self._items:
return img
pil = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
draw = ImageDraw.Draw(pil)
for x, y, text, size, color, anchor in self._items:
draw.text((x, y), text, font=self.font(size),
fill=(color[2], color[1], color[0]), anchor=PIL_ANCHOR[anchor])
self._items.clear()
return cv2.cvtColor(np.asarray(pil), cv2.COLOR_RGB2BGR)
# ==============================================================================
# 4. ファイルの取得と映像ソースの準備
# ==============================================================================
def download_asset(url: str, path: str, min_bytes: int, progress: Any) -> str:
"""未取得か大きさが不足している場合だけ取得する。progress(比率, 説明) で進捗を通知する。"""
if os.path.exists(path) and os.path.getsize(path) >= min_bytes:
return path
os.makedirs(os.path.dirname(path), exist_ok=True)
label = os.path.basename(path)
def hook(blocks: int, block_size: int, total: int) -> None:
ratio = (blocks * block_size / total) if total > 0 else 0.0
progress(clamp(ratio, 0.0, 1.0), f"{label} を取得中")
tmp = path + ".part"
urllib.request.urlretrieve(url, tmp, hook)
os.replace(tmp, path)
progress(1.0, f"{label} の取得が完了")
return path
def _first_frame_ok(cap: cv2.VideoCapture) -> bool:
return bool(cap.isOpened()) and bool(cap.read()[0])
def open_camera(index: int) -> Optional[cv2.VideoCapture]:
"""カメラを開く。DirectShow を先に、Media Foundation を次に試す。
DirectShow は一部の UVC カメラで Media Foundation に見られる長い起動待ちがない。
機種によっては DirectShow で開けないため、Media Foundation も試す(どちらも同じ
解像度・フレームレートを要求するので、処理の質は変わらない)。
FOURCC の設定は現在の幅・高さで再構成を起こすため、最後に行う。
"""
for backend in (cv2.CAP_DSHOW, cv2.CAP_MSMF):
cap = cv2.VideoCapture(index, backend)
if cap.isOpened():
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
cap.set(cv2.CAP_PROP_FPS, 30)
# MJPG を要求しないと、多くの機種で 720p が 10fps 程度に低下する
cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*"MJPG"))
if _first_frame_ok(cap):
return cap
cap.release()
return None
def open_video(path: str) -> Optional[cv2.VideoCapture]:
"""動画ファイルを開く(8.3 形式のパスを使い、非ASCIIパスでも開けるようにする)。"""
cap = cv2.VideoCapture(short_path(path))
if _first_frame_ok(cap):
cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
return cap
cap.release()
return None
# ==============================================================================
# 5. 起動設定ウィンドウ(Tkinter)
# ==============================================================================
@dataclass
class Config:
kind: str # "camera"/"file"/"demo"
cap: Any # 起動設定画面で読み出しを確認した VideoCapture
mirror: bool
calib_sec: float
use_rppg: bool
sound: bool
class Launcher:
"""映像ソースと計測条件を選ぶ起動設定画面。"""
DIM = "#666666"
HEAD = "#1F4E79"
def __init__(self) -> None:
self.config: Optional[Config] = None
self.root = tk.Tk()
self.root.title("顔特徴トレンド・モニタ - 起動設定")
self.root.resizable(False, False)
self.family = self._setup_fonts()
self.kind = tk.StringVar(value="demo")
self.cam_index = tk.IntVar(value=0)
self.file_path = tk.StringVar(value="")
self.calib = tk.StringVar(value="30")
self.mirror = tk.BooleanVar(value=False)
self.rppg = tk.BooleanVar(value=True)
self.sound = tk.BooleanVar(value=True)
self.status = tk.StringVar(value="")
self.progress = tk.DoubleVar(value=0.0)
self._build()
self.file_path.trace_add("write", lambda *_: self._update_start())
READY_TEXT = "映像ソースを選んで「計測を開始」を押してください。"
FILE_HINT = "「参照…」で動画ファイルを選ぶと、計測を開始できます。"
def _setup_fonts(self) -> str:
"""画面全体の字体を、日本語の UI 字体(メイリオ UI → 游ゴシック UI → MS UI ゴシック)に揃える。"""
families = set(tkfont.families(self.root))
default = tkfont.nametofont("TkDefaultFont").actual("family")
family = next((f for f in ("Meiryo UI", "Yu Gothic UI", "MS UI Gothic")
if f in families), default)
for name in ("TkDefaultFont", "TkTextFont", "TkMenuFont", "TkHeadingFont"):
tkfont.nametofont(name).configure(family=family, size=10)
return family
# -------------------------------------------------------------- 画面構成 --
def _build(self) -> None:
main = ttk.Frame(self.root, padding=(14, 12, 14, 12))
main.grid(row=0, column=0, sticky="nsew")
main.columnconfigure(0, weight=1)
ttk.Label(main, text="顔の特徴量の変化を、個人基準からの偏差(ロバスト z 値)として可視化します",
font=(self.family, 12, "bold")).grid(row=0, column=0, sticky="w")
ttk.Label(main, text="本プログラムは医療機器ではありません。表示値は心理状態の測定値ではなく、"
"個人基準と比べた参考値です。",
foreground=self.DIM).grid(row=1, column=0, sticky="w", pady=(2, 10))
# ---- 映像ソース ----
src = ttk.LabelFrame(main, text="映像ソース", padding=(10, 6))
src.grid(row=2, column=0, sticky="ew")
src.columnconfigure(1, weight=1)
for row, (text, value) in enumerate((("カメラ", "camera"), ("動画ファイル", "file"),
("デモ動画(自動取得)", "demo"))):
ttk.Radiobutton(src, text=text, variable=self.kind, value=value,
command=self._on_kind).grid(row=row, column=0, sticky="w", pady=3)
cam = ttk.Frame(src)
cam.grid(row=0, column=1, sticky="w", padx=(12, 0))
ttk.Label(cam, text="番号").pack(side="left")
# 読み取り専用にして、整数以外が入力されることを防ぐ
ttk.Spinbox(cam, from_=0, to=8, width=4, textvariable=self.cam_index,
state="readonly").pack(side="left", padx=(6, 10))
ttk.Label(cam, text="(映らない場合は 1, 2 … を試してください)",
foreground=self.DIM).pack(side="left")
fil = ttk.Frame(src)
fil.grid(row=1, column=1, sticky="ew", padx=(12, 0))
fil.columnconfigure(0, weight=1)
self.entry = ttk.Entry(fil, textvariable=self.file_path)
self.entry.grid(row=0, column=0, sticky="ew")
self.browse = ttk.Button(fil, text="参照…", command=self._browse)
self.browse.grid(row=0, column=1, padx=(6, 0))
ttk.Label(src, text="正面顔の公開サンプル動画(Intel IoT DevKit、初回のみ約15MBを取得)",
foreground=self.DIM).grid(row=2, column=1, sticky="w", padx=(12, 0))
# ---- 計測条件 ----
opt = ttk.LabelFrame(main, text="計測条件", padding=(10, 6))
opt.grid(row=3, column=0, sticky="ew", pady=(10, 0))
cal = ttk.Frame(opt)
cal.grid(row=0, column=0, sticky="w", pady=(2, 0))
ttk.Label(cal, text="個人基準の校正時間").pack(side="left")
ttk.Combobox(cal, textvariable=self.calib, width=5, state="readonly",
values=("20", "30", "45", "60", "90")).pack(side="left", padx=6)
ttk.Label(cal, text="秒").pack(side="left")
ttk.Label(opt, text="校正中の値が個人基準になります。普段どおりの姿勢で、正面を向いて過ごしてください。",
foreground=self.DIM).grid(row=1, column=0, sticky="w", pady=(2, 6))
for row, (text, var) in enumerate((
("映像を左右反転する(カメラ向け)", self.mirror),
("rPPG による脈拍数の推定を行う(参考値)", self.rppg),
("眠気関連指標が「高い」水準のとき音で知らせる", self.sound)), start=2):
ttk.Checkbutton(opt, text=text, variable=var).grid(row=row, column=0, sticky="w", pady=1)
# ---- 使い方と数値の定義(スクロールできる読み取り専用の欄)----
info = ttk.LabelFrame(main, text="使い方と数値の定義", padding=(6, 6))
info.grid(row=4, column=0, sticky="ew", pady=(10, 0))
info.columnconfigure(0, weight=1)
txt = tk.Text(info, width=84, height=15, wrap="char", relief="flat", borderwidth=0,
background="#FAFAFA", padx=8, pady=6, cursor="arrow",
font=(self.family, 10))
bar = ttk.Scrollbar(info, orient="vertical", command=txt.yview)
txt.configure(yscrollcommand=bar.set)
txt.grid(row=0, column=0, sticky="nsew")
bar.grid(row=0, column=1, sticky="ns")
self._fill_help(txt)
# ---- 進捗・状態・ボタン ----
ttk.Progressbar(main, variable=self.progress, maximum=1.0).grid(
row=5, column=0, sticky="ew", pady=(12, 4))
ttk.Label(main, textvariable=self.status, wraplength="460p").grid(
row=6, column=0, sticky="w")
btns = ttk.Frame(main)
btns.grid(row=7, column=0, sticky="e", pady=(10, 0))
self.start_btn = ttk.Button(btns, text="計測を開始", command=self._start)
self.start_btn.grid(row=0, column=0, padx=(0, 6))
ttk.Button(btns, text="終了", command=self.root.destroy).grid(row=0, column=1)
self._on_kind()
def _fill_help(self, txt: tk.Text) -> None:
"""説明を、見出し・項目名・説明の3種の書式で流し込む。
説明が折り返されても、2行目以降は説明の列の左端に揃う。"""
txt.tag_configure("h", font=(self.family, 10, "bold"), foreground=self.HEAD,
spacing1=8, spacing3=3)
txt.tag_configure("item", lmargin1="4p", lmargin2="80p", tabs=("80p",),
spacing1=1, spacing3=2)
txt.tag_configure("key", font=(self.family, 10, "bold"))
for title, items in HELP_SECTIONS:
txt.insert("end", "■ " + title + "\n", "h")
for label, text in items:
txt.insert("end", label, ("item", "key"))
txt.insert("end", "\t" + text + "\n", "item")
txt.configure(state="disabled")
# ------------------------------------------------------------ 画面の同期 --
def _on_kind(self) -> None:
state = "normal" if self.kind.get() == "file" else "disabled"
self.entry.configure(state=state)
self.browse.configure(state=state)
self.mirror.set(self.kind.get() == "camera")
self._update_start()
def _update_start(self) -> None:
"""動画ファイルが選ばれるまで開始ボタンを押せないようにし、状態欄の案内を合わせる。"""
ready = self.kind.get() != "file" or os.path.isfile(self.file_path.get())
self.start_btn.configure(state="normal" if ready else "disabled")
if not ready:
self.status.set(self.FILE_HINT)
elif self.status.get() in ("", self.FILE_HINT):
self.status.set(self.READY_TEXT)
def _browse(self) -> None:
path = filedialog.askopenfilename(
title="動画ファイルを選択",
filetypes=[("動画ファイル", "*.mp4 *.avi *.mov *.mkv *.wmv"),
("すべてのファイル", "*.*")])
if path:
self.file_path.set(path)
def _progress(self, ratio: float, text: str) -> None:
self.progress.set(ratio)
self.status.set(f"{text} {ratio * 100:3.0f}%")
self.root.update()
# ------------------------------------------------------------------ 開始 --
def _start(self) -> None:
kind = self.kind.get()
self.start_btn.configure(state="disabled")
self.status.set("必要なファイルを準備しています…")
self.root.update()
download_asset(MODEL_URL, MODEL_PATH, MODEL_MIN_BYTES, self._progress)
self.status.set("映像ソースを開いています…")
self.root.update()
if kind == "camera":
cap = open_camera(int(self.cam_index.get()))
hint = "カメラ番号を変えるか、他のアプリがカメラを使用していないか確認してください。"
else:
path = (self.file_path.get() if kind == "file" else
download_asset(DEMO_URL, DEMO_PATH, DEMO_MIN_BYTES, self._progress))
cap = open_video(path)
hint = "この形式は再生できません。mp4(H.264)形式の動画を選んでください。"
if cap is None:
self.status.set("映像ソースを開けませんでした。" + hint)
self.start_btn.configure(state="normal")
return
self.config = Config(kind=kind, cap=cap, mirror=bool(self.mirror.get()),
calib_sec=float(self.calib.get()),
use_rppg=bool(self.rppg.get()),
sound=bool(self.sound.get()))
self.root.destroy()
def run(self) -> Optional[Config]:
self.root.mainloop()
return self.config
# ==============================================================================
# 6. フレームごとの特徴量の抽出
# ==============================================================================
def umeyama_similarity(src: np.ndarray, dst: np.ndarray
) -> Tuple[np.ndarray, float, np.ndarray, np.ndarray]:
"""src を dst に重ねる相似変換(回転・尺度・重心)を最小二乗で求める(Umeyama 法)。"""
sc, dc = src.mean(0), dst.mean(0)
s0, d0 = src - sc, dst - dc
u, sv, vt = np.linalg.svd(s0.T @ d0)
sign = float(np.sign(np.linalg.det(vt.T @ u.T)))
rot = vt.T @ np.diag([1.0, 1.0, sign]) @ u.T
scale = float((sv * np.array([1.0, 1.0, sign])).sum() / max((s0 ** 2).sum(), 1e-9))
return rot, scale, sc, dc
class FrameExtractor:
"""顔特徴点・ブレンドシェイプ係数・顔の変換行列から、1フレーム分の特徴量を求める。
画素で測る量はすべて外眼角間距離または画像の大きさで正規化し、入力解像度に依存させない。
"""
def __init__(self) -> None:
self.prev_t: Optional[float] = None
self.prev_rot: Optional[np.ndarray] = None
self.ref_anchor: Optional[np.ndarray] = None
self.ref_iod = 1.0
self.prev_aligned: Optional[np.ndarray] = None
self.ema_yaw: Optional[float] = None
self.ema_pitch: Optional[float] = None
self.ear_hist: Deque[Tuple[float, float]] = deque(maxlen=4000)
self.ear_ref = (0.28, 0.10)
self.ear_ref_t = -9.0
def reset(self) -> None:
"""映像が不連続になったとき(先頭への巻き戻し・再校正・左右反転)に内部状態を捨てる。"""
self.prev_rot = None
self.prev_aligned = None
self.ref_anchor = None
self.ema_yaw = None
self.ema_pitch = None
self.prev_t = None
def _eye_reference(self, t: float, ear_v: float) -> Tuple[float, float]:
"""直近60秒の EAR の分布から、開眼(85パーセンタイル)と閉眼(3パーセンタイル)の
参照値を求める(0.5秒ごとに更新。30標本に満たない間は初期値を用いる)。"""
if t - self.ear_ref_t >= 0.5:
self.ear_ref_t = t
recent = [v for tt, v in self.ear_hist if tt > t - 60.0]
if len(recent) >= 30:
arr = np.asarray(recent)
self.ear_ref = (float(np.percentile(arr, 85)), float(np.percentile(arr, 3)))
else:
self.ear_ref = (max(ear_v, 0.28), 0.10)
return self.ear_ref
# --------------------------------------------------------------------------
def process(self, result, img: np.ndarray, t: float) -> Optional[Dict[str, Any]]:
if not (result.face_landmarks and result.face_blendshapes
and result.facial_transformation_matrixes):
self.prev_t = t
return None
h, w = img.shape[:2]
pts = np.array([[lm.x * w, lm.y * h, lm.z * w] for lm in result.face_landmarks[0]],
dtype=np.float64)
blend = {c.category_name: float(c.score) for c in result.face_blendshapes[0]}
def bs(name: str) -> float:
return blend.get(name, 0.0)
def pair(name: str) -> float:
"""左右のブレンドシェイプ係数の平均。"""
return 0.5 * (bs(name + "Left") + bs(name + "Right"))
iod = float(np.linalg.norm(pts[LM_IOD[1], :2] - pts[LM_IOD[0], :2]))
if iod < 0.0125 * w: # 顔が小さすぎる(外眼角間距離が画像幅の1.25%未満)
self.prev_t = t
return None
dt = 0.0
if self.prev_t is not None and 1e-3 < (t - self.prev_t) < 1.0:
dt = t - self.prev_t
# ---- 頭部姿勢(顔の変換行列の回転成分から求めるオイラー角)--------------
mat = np.asarray(result.facial_transformation_matrixes[0], dtype=np.float64)
rot = mat[:3, :3]
fwd, right = rot[:, 2], rot[:, 0]
yaw = math.degrees(math.atan2(fwd[0], fwd[2] + 1e-9))
pitch = math.degrees(math.atan2(fwd[1], math.hypot(fwd[0], fwd[2]) + 1e-9))
roll = math.degrees(math.atan2(right[1], right[0] + 1e-9))
dist = float(np.linalg.norm(mat[:3, 3]))
# ---- 閉眼度: 幾何的指標(EAR)とブレンドシェイプ係数(eyeBlink)の重み付き和 --
# 画像上の EAR の縦距離はピッチ角の余弦で、横距離はヨー角の余弦で短縮される。
# 補正しないと下を向いただけで閉眼度が上がるため、余弦比による一次補正を掛ける。
def ear(idx: List[int]) -> float:
a = np.linalg.norm(pts[idx[1], :2] - pts[idx[5], :2])
b = np.linalg.norm(pts[idx[2], :2] - pts[idx[4], :2])
c = np.linalg.norm(pts[idx[0], :2] - pts[idx[3], :2])
return float((a + b) / (2.0 * c + 1e-6))
cp = math.cos(math.radians(clamp(pitch, -35.0, 35.0)))
cy = math.cos(math.radians(clamp(yaw, -35.0, 35.0)))
pose_gain = clamp(cy / max(cp, 1e-3), 0.70, 1.60)
ear_v = 0.5 * (ear(LM_R_EYE) + ear(LM_L_EYE)) * pose_gain
self.ear_hist.append((t, ear_v))
open_ref, close_ref = self._eye_reference(t, ear_v)
span = max(open_ref - close_ref, 0.045)
closure = clamp(0.55 * clamp((open_ref - ear_v) / span, 0.0, 1.4)
+ 0.45 * pair("eyeBlink"), 0.0, 1.3)
# ---- 口・眉・眼瞼・頬(ブレンドシェイプ係数。AU は FACS への近似的な対応)--
mar = float(np.linalg.norm(pts[LM_MOUTH_V[0], :2] - pts[LM_MOUTH_V[1], :2])
/ (np.linalg.norm(pts[LM_MOUTH_H[0], :2] - pts[LM_MOUTH_H[1], :2]) + 1e-6))
jaw_open = clamp(max(bs("jawOpen"), clamp((mar - 0.06) / 0.55, 0.0, 1.0)), 0.0, 1.0)
brow_up = clamp(0.5 * bs("browInnerUp") + 0.5 * pair("browOuterUp"), 0.0, 1.0)
brow_down = clamp(pair("browDown"), 0.0, 1.0)
squint = clamp(pair("eyeSquint"), 0.0, 1.0)
cheek_raise = clamp(pair("cheekSquint"), 0.0, 1.0)
smile = clamp(pair("mouthSmile"), 0.0, 1.0)
mouth_press = clamp(0.7 * pair("mouthPress") + 0.3 * pair("mouthFrown"), 0.0, 1.0)
# ---- 視線(頭部座標系における眼球の向きを表すブレンドシェイプ係数から求める)--
gaze_h = 0.5 * ((bs("eyeLookOutLeft") - bs("eyeLookInLeft"))
+ (bs("eyeLookInRight") - bs("eyeLookOutRight")))
gaze_dn = pair("eyeLookDown")
gaze_v = pair("eyeLookUp") - gaze_dn
# 画像内での眼の高さ(両外眼角の中点の縦座標 ÷ 画像の高さ)。増加=下方へ移動
head_drop = float((pts[LM_IOD[0], 1] + pts[LM_IOD[1], 1]) * 0.5 / h)
# 頭部の角速度: 前フレームとの相対回転の回転角 ÷ 時間間隔
head_speed = 0.0
if self.prev_rot is not None and dt > 0:
rel = rot @ self.prev_rot.T
cosang = clamp((float(np.trace(rel)) - 1.0) * 0.5, -1.0, 1.0)
head_speed = clamp(math.degrees(math.acos(cosang)) / dt, 0.0, 300.0)
self.prev_rot = rot
# 頭部の微小動揺: ヨー角・ピッチ角と、それぞれの指数移動平均(時定数0.6秒)との差の絶対値の和
alpha = 1.0 - math.exp(-dt / 0.6) if dt > 0 else 0.25
self.ema_yaw = yaw if self.ema_yaw is None else self.ema_yaw + alpha * (yaw - self.ema_yaw)
self.ema_pitch = (pitch if self.ema_pitch is None
else self.ema_pitch + alpha * (pitch - self.ema_pitch))
jitter = clamp(abs(yaw - self.ema_yaw) + abs(pitch - self.ema_pitch), 0.0, 30.0)
# ---- 顔面内部の運動量(相似変換で頭部運動を除いた後の特徴点の移動速度)----
anchor, expr = pts[ANCHOR_IDX], pts[EXPR_IDX]
if self.ref_anchor is None:
self.ref_anchor = anchor.copy()
self.ref_iod = iod
self.prev_aligned = None
r2, s2, sc, dc = umeyama_similarity(anchor, self.ref_anchor)
aligned = (s2 * (r2 @ (expr - sc).T).T) + dc
inner_motion = 0.0
if self.prev_aligned is not None and dt > 0:
moved = float(np.mean(np.linalg.norm(aligned - self.prev_aligned, axis=1)))
inner_motion = clamp(moved / self.ref_iod * 100.0 / dt, 0.0, 300.0)
self.prev_aligned = aligned
# ---- 画像品質スコア(顔領域の輝度・顔の大きさ・ヨー角の重み付き和)------
x0 = int(clamp(pts[:, 0].min(), 0, w - 2))
x1 = int(clamp(pts[:, 0].max(), x0 + 1, w - 1))
y0 = int(clamp(pts[:, 1].min(), 0, h - 2))
y1 = int(clamp(pts[:, 1].max(), y0 + 1, h - 1))
lum = float(img[y0:y1, x0:x1].mean()) / 255.0
quality = clamp(0.35 * clamp(1.0 - abs(lum - 0.52) / 0.45, 0.0, 1.0)
+ 0.30 * clamp(iod / (0.086 * w), 0.0, 1.0)
+ 0.35 * clamp(1.0 - max(abs(yaw) - 12.0, 0.0) / 55.0, 0.0, 1.0),
0.0, 1.0)
self.prev_t = t
return dict(
t=t, closure=closure, eye_open=clamp(1.0 - closure, 0.0, 1.0),
perclos_flag=1.0 if closure >= 0.80 else 0.0,
jaw_open=jaw_open, brow_up=brow_up, brow_down=brow_down, squint=squint,
cheek_raise=cheek_raise, smile=smile, mouth_press=mouth_press,
gaze_h=gaze_h, gaze_v=gaze_v, gaze_down=clamp(gaze_dn, 0.0, 1.0),
yaw=yaw, pitch=pitch, roll=roll, head_speed=head_speed, jitter=jitter,
inner_motion=inner_motion, dist=dist, head_drop=head_drop, quality=quality,
iod=iod, rois=self._rois(pts, w, h), points=pts, rot=rot)
@staticmethod
def _rois(pts: np.ndarray, w: int, h: int) -> List[Tuple[int, int, int, int]]:
"""rPPG に用いる額・左頬・右頬の矩形領域を求める。"""
boxes = []
for idx, sx, sy in (([10, 67, 297, 9], 0.72, 0.52),
([50, 101, 118, 205], 0.72, 0.60),
([280, 330, 347, 425], 0.72, 0.60)):
q = pts[idx, :2]
cx = (q[:, 0].min() + q[:, 0].max()) * 0.5
cy = (q[:, 1].min() + q[:, 1].max()) * 0.5
bw = (q[:, 0].max() - q[:, 0].min()) * sx * 0.5
bh = (q[:, 1].max() - q[:, 1].min()) * sy * 0.5
box = (int(clamp(cx - bw, 0, w - 2)), int(clamp(cy - bh, 0, h - 2)),
int(clamp(cx + bw, 1, w - 1)), int(clamp(cy + bh, 1, h - 1)))
if box[2] - box[0] >= 6 and box[3] - box[1] >= 6:
boxes.append(box)
return boxes
# ==============================================================================
# 7. 事象の検出(瞬目・あくび)
# ==============================================================================
class BlinkDetector:
"""閉眼度のヒステリシス(開始 0.68/終了 0.42)で瞬目を検出し、
持続時間は閉眼度 0.5 の上向き交差から下向き交差まで(線形補間)で測る。
上向き交差を観測していない場合(計測開始直後や巻き戻し直後に既に閉眼していた場合)は、
起点が不明なので、開始判定の時刻を起点とする。
"""
ENTER, EXIT, HALF = 0.68, 0.42, 0.50
MIN_DUR, MAX_DUR, REFRACT, LONG_CLOSE = 0.04, 0.90, 0.12, 2.5
def __init__(self) -> None:
self.reset()
def reset(self) -> None:
self.active = False
self.prev: Optional[Tuple[float, float]] = None
self.t_up = NAN
self.t_start = 0.0
self.t_end = -9.0
def update(self, t: float, closure: float) -> Optional[float]:
prev, self.prev = self.prev, (t, closure)
t_down: Optional[float] = None
if prev is not None:
pt, pc = prev
if (pc < self.HALF <= closure) or (pc >= self.HALF > closure):
frac = (self.HALF - pc) / (closure - pc)
t_cross = pt + clamp(frac, 0.0, 1.0) * (t - pt)
if closure > pc:
self.t_up = t_cross
else:
t_down = t_cross
if not self.active:
if closure >= self.ENTER and (t - self.t_end) > self.REFRACT:
self.active = True
usable = isnum(self.t_up) and 0.0 <= (t - self.t_up) <= self.LONG_CLOSE
self.t_start = self.t_up if usable else t
return None
if closure <= self.EXIT:
self.active = False
self.t_end = t
dur = (t_down if t_down is not None else t) - self.t_start
return dur if self.MIN_DUR <= dur <= self.MAX_DUR else None
if t - self.t_start > self.LONG_CLOSE: # 2.5秒を超える閉眼は瞬目に含めない
self.active = False
self.t_end = t
return None
class YawnDetector:
"""開口度 0.52 以上で開始、0.30 以下で終了し、持続 1.2秒以上かつ最大値 0.62 以上をあくびとする。
閾値は発話や笑いによる開口を除くための経験値であり、個人基準は用いない。
"""
ENTER, EXIT, PEAK, MIN_DUR, REFRACT = 0.52, 0.30, 0.62, 1.2, 8.0
def __init__(self) -> None:
self.reset()
def reset(self) -> None:
self.active = False
self.t_start = 0.0
self.peak = 0.0
self.t_last = -99.0
def update(self, t: float, jaw_open: float) -> Optional[float]:
if not self.active:
if jaw_open >= self.ENTER:
self.active, self.t_start, self.peak = True, t, jaw_open
return None
self.peak = max(self.peak, jaw_open)
if jaw_open <= self.EXIT:
self.active = False
dur = t - self.t_start
if dur >= self.MIN_DUR and self.peak >= self.PEAK and (t - self.t_last) > self.REFRACT:
self.t_last = t
return dur
return None
# ==============================================================================
# 8. rPPG(脈拍数の参考値・POS 法)
# ==============================================================================
class RPPG:
"""額と両頬の平均色から脈波成分を取り出す(Plane-Orthogonal-to-Skin 法; Wang ら, 2017)。
rPPG が捉えるのは皮膚の血液容積変化(脈波)なので、得られるのは心拍数ではなく脈拍数である。
"""
FS = 30.0 # 再標本化の周波数[Hz]
WIN = 12.0 # 解析窓[秒]
MIN_WIN = 8.0
MAX_GAP = 0.5 # 窓内で許す標本の最大間隔[秒](超える欠落は補間せず推定を見送る)
BAND = (0.70, 3.00) # 通過帯域 42〜180 bpm
INTERVAL = 1.0 # 推定の間隔[秒]
PROJ = np.array([[0.0, 1.0, -1.0], [-2.0, 1.0, 1.0]])
def __init__(self) -> None:
self.buf: Deque[Tuple[float, float, float, float, float]] = deque(maxlen=1500)
self.bpm: Deque[Tuple[float, float]] = deque(maxlen=900)
self.t_last = -9.0
self.conf = 0.0
def reset(self) -> None:
self.buf.clear()
self.bpm.clear()
self.conf = 0.0
def push(self, t: float, img: np.ndarray, rois, head_speed: float) -> None:
"""面積で重み付けした平均 RGB を蓄える(白飛び・黒つぶれの領域は除く)。"""
total, acc = 0.0, np.zeros(3)
for x0, y0, x1, y1 in rois:
mean = img[y0:y1, x0:x1].reshape(-1, 3).mean(0)
if mean.max() > 250 or mean.max() < 12:
continue
area = float((x1 - x0) * (y1 - y0))
acc += mean * area
total += area
if total > 0:
b, g, r = acc / total
self.buf.append((t, r, g, b, head_speed))
def estimate(self, t: float) -> Tuple[float, float]:
if t - self.t_last < self.INTERVAL:
return self.current(t)
self.t_last = t
data = [row for row in self.buf if row[0] > t - self.WIN]
if len(data) < 80:
return self.current(t)
arr = np.asarray(data)
ts = arr[:, 0]
n = int((ts[-1] - ts[0]) * self.FS)
span = int(1.6 * self.FS)
# 窓長の不足、標本の欠落(顔の見失いなど)、頭部の動きが多い区間
# (角速度10度/秒未満のフレームが70%未満)は推定しない
if (ts[-1] - ts[0] < self.MIN_WIN or n < 128 or n <= span + 4
or float(np.max(np.diff(ts))) > self.MAX_GAP
or float(np.mean(arr[:, 4] < 10.0)) < 0.70):
return self.current(t)
# 等間隔 1/FS の格子で再標本化する(周波数軸を FS と厳密に一致させる)
grid = ts[0] + np.arange(n) / self.FS
rgb = np.stack([np.interp(grid, ts, arr[:, i]) for i in (1, 2, 3)], axis=1)
# POS: 1.6秒の窓ごとに時間正規化した RGB を射影し、重畳加算する
win = sliding_window_view(rgb, span, axis=0) # (m, 3, span)
norm = win / (win.mean(axis=2, keepdims=True) + 1e-9)
s = np.einsum("ij,mjk->mik", self.PROJ, norm)
s0, s1 = s[:, 0, :], s[:, 1, :]
gain = s0.std(axis=1) / (s1.std(axis=1) + 1e-9)
hsig = s0 + gain[:, None] * s1
hsig -= hsig.mean(axis=1, keepdims=True)
idx = np.arange(hsig.shape[0])[:, None] + np.arange(span)[None, :]
sig = np.bincount(idx.ravel(), weights=hsig.ravel(), minlength=n)[:n]
sig -= sig.mean()
if sig.std() < 1e-9:
return self.current(t)
spec = np.abs(np.fft.rfft(sig / sig.std() * np.hanning(n), 4096)) ** 2
freq = np.fft.rfftfreq(4096, 1.0 / self.FS)
band = (freq >= self.BAND[0]) & (freq <= self.BAND[1])
power, fb = spec[band], freq[band]
peak = float(fb[int(np.argmax(power))])
# スペクトル集中度: 帯域内パワーのうち、ピーク周波数と第2高調波の近傍(±0.16Hz)が
# 占める比を 0〜1 に線形変換した値
near = (np.abs(fb - peak) <= 0.16) | (np.abs(fb - 2.0 * peak) <= 0.16)
ratio = float(power[near].sum() / (power.sum() + 1e-12))
self.conf = clamp((ratio - 0.16) / 0.38, 0.0, 1.0)
# ピーク近傍(±0.10Hz)のパワー重心で周波数を補間する
lobe = np.abs(fb - peak) <= 0.10
f_est = float((fb[lobe] * power[lobe]).sum() / (power[lobe].sum() + 1e-12))
if 40.0 <= f_est * 60.0 <= 160.0 and self.conf >= 0.30:
self.bpm.append((t, f_est * 60.0))
return self.current(t)
def current(self, t: float) -> Tuple[float, float]:
"""直近25秒の推定値が2個以上あれば、その中央値を返す。"""
vals = [b for tt, b in self.bpm if tt > t - 25.0]
return (float(np.median(vals)) if len(vals) >= 2 else NAN), self.conf
# ==============================================================================
# 9. 時系列解析
# ==============================================================================
@dataclass
class Stat:
now: float = NAN # 現在値(直近60秒の代表値)
base: float = NAN # 個人基準
mad: float = NAN # 校正期間の中央絶対偏差
z: float = NAN # ロバスト z 値
slope: float = NAN # Theil–Sen 傾き[単位/分]
tau: float = NAN # Kendall の τb
@dataclass
class IndexState:
value: float = NAN # 指数平滑化後の値
raw: float = NAN # 平滑化前の重み付き平均
slope: float = NAN
tau: float = NAN
level: int = 1
cand: int = 1
cand_since: float = 0.0
coverage: float = NAN # z が得られた成分の重みの割合
parts: List[Tuple[str, float, float, float]] = field(default_factory=list) # (特徴量, w, z, w·clip(z))
level_time: List[float] = field(default_factory=lambda: [0.0, 0.0, 0.0, 0.0])
hi: Tuple[float, float] = (NAN, 0.0)
lo: Tuple[float, float] = (NAN, 0.0)
@property
def contrib(self) -> List[Tuple[str, float, float]]:
"""寄与の絶対値が大きい上位3成分 (特徴量, 寄与, z)。"""
valid = [(k, p, z) for k, _, z, p in self.parts if isnum(z)]
return sorted(valid, key=lambda c: -abs(c[1]))[:3]
def contrib_text(self, n: int = 3) -> str:
"""寄与上位 n 成分の特徴量名と z を並べた文。"""
return "、".join(f"{METRIC_MAP[k].name} z={z:+.1f}" for k, _, z in self.contrib[:n])
def level_of(value: float, current: int) -> int:
"""境界値にヒステリシスを設けて水準(0〜3)を決める。"""
if not isnum(value):
return current
adj = [LEVEL_EDGES[i] + (LEVEL_HYST if current <= i else -LEVEL_HYST) for i in range(3)]
return sum(1 for a in adj if value >= a)
class Analyzer:
"""フレーム値 → 1秒値 → 窓統計 → 総合指標 → 水準判定。"""
def __init__(self, calib_sec: float) -> None:
self.calib_sec = calib_sec
self.series: Dict[str, Deque[Tuple[float, float]]] = {
m.key: deque(maxlen=HIST_TICKS) for m in METRICS}
self.idx_series: Dict[str, Deque[Tuple[float, float]]] = {
i.key: deque(maxlen=HIST_TICKS) for i in INDEXES}
self.stats: Dict[str, Stat] = {m.key: Stat() for m in METRICS}
self.index: Dict[str, IndexState] = {i.key: IndexState() for i in INDEXES}
self.ref_hist: Dict[str, Deque[float]] = {k: deque(maxlen=900) for k in REF_KEYS}
self.ref: Dict[str, float] = {k: NAN for k in REF_KEYS}
self.calib_gaze: Deque[Tuple[float, float]] = deque(maxlen=6000)
self.gaze_off_dev = GAZE_OFF_DEFAULT
self.rows: Deque[Dict[str, float]] = deque(maxlen=HIST_TICKS)
self.events: Deque[Tuple[float, str, Tuple[int, int, int]]] = deque(maxlen=500)
self.marks: Deque[Tuple[float, Tuple[int, int, int]]] = deque(maxlen=500)
self.transitions: Deque[Tuple[float, str]] = deque(maxlen=200)
self.findings: List[Tuple[str, Optional[str], str]] = [] # (文, 特徴量, 種別)
self.summary: Tuple[str, str, Tuple[int, int, int]] = (
"計測を開始しました", "顔が映る位置に座ってください。", C_DIM)
self.blinks: Deque[Tuple[float, float]] = deque(maxlen=6000)
self.yawns: Deque[float] = deque(maxlen=600)
self.frames: List[Dict[str, float]] = []
self.calib_rows: List[Dict[str, float]] = []
self.calib_t0: Optional[float] = None
self.calibrated = False
self.calib_end = NAN
self.tick_t0: Optional[float] = None
self.tick_frames = 0
self.tick_valid = 0
self.t_now = 0.0
self.t_origin: Optional[float] = None
self.n_blink_total = 0
self.n_yawn_total = 0
self.t_long_blink_event = -99.0
self.t_alert = -999.0
self.pending_alert = False
@property
def t0(self) -> float:
return self.t_origin if self.t_origin is not None else 0.0
@property
def elapsed(self) -> float:
"""最初のフレームからの経過時間[秒]。"""
return max(self.t_now - self.t0, 0.0)
@property
def n_long_blinks(self) -> int:
return sum(1 for _, d in self.blinks if d >= LONG_BLINK)
# ------------------------------------------------------------ 入力 ------
def add_frame(self, feat: Optional[Dict[str, Any]], t: float,
hr: float, hr_conf: float) -> bool:
"""1フレームを投入する。1秒値が確定したら True を返す。"""
if self.tick_t0 is None:
self.tick_t0 = t
if self.t_origin is None:
self.t_origin = t
self.tick_frames += 1
if feat is not None and feat["quality"] >= QUALITY_MIN:
row = {k: feat[k] for k in FRAME_KEYS}
row["hr"], row["hr_conf"] = hr, hr_conf
self.tick_valid += 1
self.frames.append(row)
if self.calib_t0 is None:
self.calib_t0 = t
if t - self.tick_t0 >= TICK_SEC:
self._close_tick(t)
return True
return False
def note_blink(self, t: float, dur: float) -> None:
self.blinks.append((t, dur))
self.n_blink_total += 1
if dur >= LONG_BLINK and (t - self.t_long_blink_event) >= 60.0:
self.t_long_blink_event = t
count = sum(1 for tt, d in self.blinks if d >= LONG_BLINK and tt > t - 60.0)
self.add_event(t, f"持続400ms以上の瞬目(直近60秒で {count} 回)", C_WARN)
def note_yawn(self, t: float, dur: float) -> None:
self.yawns.append(t)
self.n_yawn_total += 1
self.add_event(t, f"あくびを検出(持続 {dur:.1f}秒)", C_WARN, mark=True)
def add_event(self, t: float, text: str, color: Tuple[int, int, int],
mark: bool = False) -> None:
self.events.append((t, text, color))
if mark:
self.marks.append((t, color))
def mirror_refs(self) -> None:
"""映像の左右反転の切り替えに合わせ、左右で符号が反転する量の基準と蓄積値を反転する。
反転しないと、切り替えた直後から頭部ヨー角・ロール角の偏差と視線の逸脱率が
実際の変化と無関係に跳ね上がる。
"""
for key in MIRROR_KEYS:
self.ref[key] = -self.ref[key]
self.ref_hist[key] = deque((-v for v in self.ref_hist[key]), maxlen=900)
for f in self.frames:
f[key] = -f[key]
self.calib_gaze = deque(((-h, v) for h, v in self.calib_gaze), maxlen=6000)
# ----------------------------------------------------- 1秒値の確定 ------
def _close_tick(self, t: float) -> None:
self.t_now = t
elapsed = max(t - self.t0, 1.0)
vals: Dict[str, float] = {m.key: NAN for m in METRICS}
frames = self.frames
if frames:
for key in MEDIAN_KEYS:
vals[key] = median_of([f[key] for f in frames])
vals["perclos"] = float(np.mean([f["perclos_flag"] for f in frames]))
for key in REF_KEYS:
self.ref_hist[key].append(median_of([f[key] for f in frames]))
if not self.calibrated:
# 視線の判定幅を決めるため、校正中はフレームごとの視線を蓄える
self.calib_gaze.extend((f["gaze_h"], f["gaze_v"]) for f in frames)
ref = {k: self._reference(k) for k in REF_KEYS}
vals["yaw_dev"] = abs(self.ref_hist["yaw"][-1] - ref["yaw"])
vals["roll_dev"] = abs(self.ref_hist["roll"][-1] - ref["roll"])
vals["gaze_off_rate"] = float(np.mean([
1.0 if (math.hypot(f["gaze_h"] - ref["gaze_h"],
f["gaze_v"] - ref["gaze_v"]) > self.gaze_off_dev
or abs(f["yaw"] - ref["yaw"]) > YAW_OFF_DEG) else 0.0
for f in frames]))
vals["coverage"] = self.tick_valid / max(self.tick_frames, 1)
# 事象の頻度は、経過時間が窓長に満たない間は経過時間(下限あり)で割る
win_b = clamp(elapsed, 15.0, WIN_BLINK)
recent = [d for tt, d in self.blinks if tt > t - win_b]
vals["blink_rate"] = 60.0 * len(recent) / win_b
vals["blink_dur"] = median_of(recent) if len(recent) >= 2 else NAN
vals["long_blink_rate"] = 60.0 * sum(1 for d in recent if d >= LONG_BLINK) / win_b
win_y = clamp(elapsed, 45.0, WIN_YAWN)
vals["yawn_rate"] = 60.0 * sum(1 for tt in self.yawns if tt > t - win_y) / win_y
for key, value in vals.items():
self.series[key].append((t, float(value)))
if not self.calibrated and self.calib_t0 is not None:
if vals["coverage"] >= 0.5:
self.calib_rows.append(vals)
if (t - self.calib_t0) >= self.calib_sec and len(self.calib_rows) >= 10:
self._finish_calibration(t)
self._update_stats(t)
if self.calibrated:
self._update_indexes(t)
self._update_findings()
self._update_summary()
row: Dict[str, float] = {"t": t}
row.update(vals)
for spec in INDEXES:
row[spec.key] = self.index[spec.key].value
self.rows.append(row)
self.frames.clear()
self.tick_t0 = t
self.tick_frames = 0
self.tick_valid = 0
# ------------------------------------------------------------ 校正 ------
def _reference(self, key: str) -> float:
"""個人基準の向き(校正完了前は、それまでの中央値を暫定の基準とする)。"""
fixed = self.ref[key]
return fixed if isnum(fixed) else median_of(list(self.ref_hist[key]))
def _finish_calibration(self, t: float) -> None:
for m in METRICS:
xs = [r[m.key] for r in self.calib_rows if isnum(r.get(m.key))]
if len(xs) >= 5:
med = median_of(xs)
st = self.stats[m.key]
st.base = float(np.mean(xs)) if m.agg == "mean" else med
st.mad = mad_of(xs, med)
for key in REF_KEYS:
self.ref[key] = median_of(list(self.ref_hist[key]))
# 視線の判定幅 = 校正期間の偏差の90パーセンタイル × 1.8(上限・下限で制限)
devs = [math.hypot(h - self.ref["gaze_h"], v - self.ref["gaze_v"])
for h, v in self.calib_gaze if isnum(h) and isnum(v)]
if len(devs) >= 60 and isnum(self.ref["gaze_h"]) and isnum(self.ref["gaze_v"]):
self.gaze_off_dev = clamp(GAZE_OFF_GAIN * float(np.percentile(devs, 90)),
GAZE_OFF_MIN, GAZE_OFF_MAX)
self.calib_gaze.clear()
self.calibrated = True
self.calib_end = t
self.add_event(t, f"個人基準の校正が完了(1秒値 {len(self.calib_rows)} 個/"
f"視線の判定幅 {self.gaze_off_dev:.2f})", C_OK, mark=True)
def recalibrate(self, t: float) -> None:
self.calibrated = False
self.calib_end = NAN
self.calib_rows.clear()
self.calib_t0 = None
self.calib_gaze.clear()
self.gaze_off_dev = GAZE_OFF_DEFAULT
for key in REF_KEYS:
self.ref_hist[key].clear()
self.ref[key] = NAN
for key in self.stats:
self.stats[key] = Stat()
for key in self.index:
self.index[key] = IndexState(level_time=self.index[key].level_time)
self.idx_series[key].clear()
self.add_event(t, "個人基準を取り直しています", C_ACC, mark=True)
# -------------------------------------------------------- 窓統計 --------
@staticmethod
def _window(series: Deque[Tuple[float, float]], sec: float, now: float
) -> Tuple[np.ndarray, np.ndarray]:
"""now から sec 秒前までの有効な (時刻, 値) を配列で返す。"""
ts, vs = [], []
for tt, vv in reversed(series):
if tt < now - sec:
break
if vv == vv:
ts.append(tt)
vs.append(vv)
return np.asarray(ts[::-1], float), np.asarray(vs[::-1], float)
def window(self, key: str, sec: float, now: float) -> Tuple[np.ndarray, np.ndarray]:
return self._window(self.series[key], sec, now)
def smoothed_window(self, m: MetricSpec, sec: float, now: float
) -> Tuple[np.ndarray, np.ndarray]:
"""窓内の1秒値。割合量は1秒ごとの 0/1 に近い値の揺れが大きいため15点移動平均をとる。"""
ts, vs = self.window(m.key, sec, now)
return ts, (rolling_mean(vs, SMOOTH_TICKS) if m.agg == "mean" else vs)
def band_of(self, m: MetricSpec) -> float:
"""z = ±1 に相当する幅(1.4826×MAD、下限あり)。"""
st = self.stats[m.key]
return sigma_scale(m, st.mad, st.base)
def _update_stats(self, t: float) -> None:
for m in METRICS:
st = self.stats[m.key]
_, vs = self.window(m.key, WIN_NOW, t)
st.now = ((float(np.mean(vs)) if m.agg == "mean" else float(np.median(vs)))
if vs.size else NAN)
st.z = (clamp((st.now - st.base) / self.band_of(m), -4.0, 4.0)
if isnum(st.base) and isnum(st.now) else NAN)
if m.analyze:
st.slope, st.tau = trend_of(*self.smoothed_window(m, WIN_TREND, t))
# ------------------------------------------------------ 総合指標 --------
def _update_indexes(self, t: float) -> None:
alpha = 1.0 - math.exp(-TICK_SEC / INDEX_TAU)
for spec in INDEXES:
st = self.index[spec.key]
parts, acc, wsum = [], 0.0, 0.0
for key, weight in spec.comps:
z = self.stats[key].z
part = weight * clamp(z, -3.0, 3.0) if isnum(z) else NAN
parts.append((key, weight, z, part))
if isnum(z):
acc += part
wsum += abs(weight)
st.parts = parts
st.coverage = wsum / INDEX_TOTAL_W[spec.key]
# z が得られた成分の重みが全体の60%に満たない間は算出しない
if st.coverage < INDEX_MIN_WEIGHT:
continue
st.raw = acc / wsum
st.value = st.raw if not isnum(st.value) else st.value + alpha * (st.raw - st.value)
self.idx_series[spec.key].append((t, st.value))
if not isnum(st.hi[0]) or st.value > st.hi[0]:
st.hi = (st.value, t)
if not isnum(st.lo[0]) or st.value < st.lo[0]:
st.lo = (st.value, t)
st.slope, st.tau = trend_of(*self._window(self.idx_series[spec.key], WIN_TREND, t))
level = level_of(st.value, st.level)
if level != st.cand:
st.cand, st.cand_since = level, t
if level != st.level and (t - st.cand_since) >= DWELL_SEC:
before, st.level = st.level, level
head = f"【{spec.name}】{LEVELS[before]} → {LEVELS[level]}"
self.transitions.append((t, head))
self.add_event(t, f"{head}(指標値 {st.value:+.2f}/{st.contrib_text()})",
spec.color, mark=True)
st.level_time[st.level] += TICK_SEC
if spec.key == "drowsy" and st.level >= 3 and (t - self.t_alert) >= ALERT_INTERVAL:
self.t_alert = t
self.pending_alert = True
self.add_event(t, "眠気関連指標が「高い」水準です。休憩を検討してください。",
C_BAD, mark=True)
# ------------------------------------------------------------ 所見 ------
def _update_findings(self) -> None:
cov = self.stats["coverage"].now
items: List[Tuple[str, Optional[str], str]] = []
if isnum(cov) and cov < 0.5:
items.append(("△ 有効フレーム率が50%未満です(カメラの画角・明るさを確認してください)",
None, "warn"))
scored = []
for m in METRICS:
st = self.stats[m.key]
if m.key not in INDEX_KEYS or not isnum(st.z):
continue
strength = abs(st.tau) if isnum(st.tau) else 0.0
if abs(st.z) >= 0.9 or strength >= 0.32:
scored.append((abs(st.z) + 1.5 * (strength if strength >= 0.28 else 0.0), m, st))
scored.sort(key=lambda s: -s[0])
for _, m, st in scored[:5 - len(items)]:
arrow = trend_arrow(st.tau)
text = (f"{arrow} {m.name}: 基準 {fmt_value(m, st.base)} → "
f"現在 {fmt_value(m, st.now)}{m.unit}(z={st.z:+.1f}")
if isnum(st.slope):
text += f"、傾き {fmt_slope(m, st.slope)}{slope_unit(m)}、τb={st.tau:+.2f}"
else:
text += "、傾き・τは記録90秒未満のため未算出"
items.append((text + ")", m.key,
"up" if arrow == "↗" else ("down" if arrow == "↘" else "flat")))
if not items:
items.append(("→ 目立った変化はありません(全特徴量で |z|<0.9 かつ |τb|<0.32)",
None, "flat"))
self.findings = items
# ------------------------------------------------------ 現在の状態 ------
def _update_summary(self) -> None:
if not self.calibrated:
self.summary = ("個人基準を校正しています",
"この間の値が個人基準になります。普段どおりの姿勢でお待ちください。",
C_WARN)
return
parts = [f"{s.name} {LEVELS[self.index[s.key].level]}{trend_arrow(self.index[s.key].tau)}"
for s in INDEXES if isnum(self.index[s.key].value)]
if not parts:
self.summary = ("計測中", "総合指標の算出に必要な特徴量がまだそろっていません。", C_DIM)
return
pick = next((k for k in ("drowsy", "tension") if self.index[k].level >= 2), None)
if pick is None:
if self.index["focus"].level == 0:
pick = "focus"
elif self.index["positive"].level >= 2:
pick = "positive"
if pick is None:
detail = "助言の条件に該当する総合指標はありません(指標は目安であり、状態の診断ではありません)。"
color = C_OK
else:
spec, st = INDEX_MAP[pick], self.index[pick]
detail = f"根拠(寄与上位): {st.contrib_text(2)} / {spec.advice}"
color = C_OK if pick == "positive" else spec.color
self.summary = (" / ".join(parts), detail, color)
# ------------------------------------------------------ 前半→後半 -------
@staticmethod
def arc_of(series) -> Optional[Tuple[float, float]]:
"""前半1/3と後半1/3の平均を返す(記録が24個未満なら None)。"""
data = [v for _, v in series if v == v]
if len(data) < 24:
return None
k = max(8, len(data) // 3)
return float(np.mean(data[:k])), float(np.mean(data[-k:]))
def index_arcs(self) -> List[Tuple[IndexSpec, float, float]]:
out = []
for spec in INDEXES:
arc = self.arc_of(self.idx_series[spec.key])
if arc is not None:
out.append((spec, arc[0], arc[1]))
return out
def metric_arcs(self) -> List[Tuple[MetricSpec, float, float, float]]:
"""前半1/3→後半1/3 の変化を z の尺度(1.4826×MAD)で割った値の大きい順。"""
out = []
for m in METRICS:
st = self.stats[m.key]
arc = self.arc_of(self.series[m.key])
if not m.analyze or m.key not in INDEX_KEYS or arc is None or not isnum(st.base):
continue
out.append((m, arc[0], arc[1], (arc[1] - arc[0]) / self.band_of(m)))
out.sort(key=lambda r: -abs(r[3]))
return out
# ---------------------------------------------------------- 記録出力 ----
def write_records(self, paths: Dict[str, str], dash_img: np.ndarray,
summary_img: np.ndarray) -> None:
with open(paths["txt"], "w", encoding="utf-8") as fp:
fp.write(self.report())
# 1秒値は画面と同じ表示単位(% や ms)で書き出す
columns = ([(m.key, m.label, m.scale) for m in METRICS]
+ [(i.key, f"総合指標:{i.name}", 1.0) for i in INDEXES])
with open(paths["csv"], "w", newline="", encoding="utf-8-sig") as fp:
writer = csv.writer(fp)
writer.writerow(["経過[秒]", "経過[mm:ss]"] + [label for _, label, _ in columns])
for row in self.rows:
writer.writerow([f"{row['t']:.2f}", fmt_clock(row["t"])]
+ ["" if not isnum(row.get(k)) else f"{row[k] * s:.5f}"
for k, _, s in columns])
save_image(paths["dash"], dash_img)
save_image(paths["sum"], summary_img)
def report(self) -> str:
out: List[str] = ["=" * 78, "顔特徴トレンド・モニタ セッションレポート",
time.strftime("作成日時: %Y-%m-%d %H:%M:%S"), "=" * 78]
out.append(f"計測時間: {self.elapsed / 60.0:.1f} 分 "
f"個人基準: {'校正済み' if self.calibrated else '未完了'} "
f"視線の判定幅: {self.gaze_off_dev:.2f}")
out.append("z = (現在値 − 個人基準) ÷ max(1.4826 × MAD, 下限)(ロバスト z 値、±4で打ち切り)")
out.append("傾き: 直近180秒の Theil–Sen 推定量、τb: Kendall の順位相関係数(1秒値90個以上で算出)")
out.append("1秒値は自己相関が強いため、τb は記述統計量であり有意性の検定には使えません。")
out += ["", "[現在の状態] " + self.summary[0], " " + self.summary[1], ""]
out.append("[総合指標] Σ w·clip(z,±3) ÷ Σ|w| を時定数15秒で指数平滑化(0=個人基準。重みは未検証の目安)")
for spec in INDEXES:
st = self.index[spec.key]
if not isnum(st.value):
continue
slope = f"{st.slope:+.3f}/分 (τb={st.tau:+.2f})" if isnum(st.slope) else "傾き未算出"
out.append(f" ・{spec.name}: {st.value:+.2f} [{LEVELS[st.level]}] "
f"{trend_arrow(st.tau)} {slope}")
for key, w, z, part in st.parts:
zt = f"{z:+.2f}" if isnum(z) else " -- "
pt = f"{part:+.3f}" if isnum(part) else "--"
out.append(f" └ {pad_display(METRIC_MAP[key].name, 26)} "
f"w={w:+.2f} z={zt} w·clip(z)={pt}")
out += ["", "[セッションの推移] 前半1/3と後半1/3の平均の比較"]
arcs = self.index_arcs()
if not arcs:
out.append(" (比較できる長さの記録がありません)")
for spec, first, last in arcs:
out.append(f" ・{pad_display(spec.name, 16)} {first:+.2f} → {last:+.2f}"
f"({last - first:+.2f}){change_word(last - first, 0.25)}")
for m, first, last, dz in self.metric_arcs()[:5]:
out.append(f" └ {pad_display(m.name, 26)} {fmt_value(m, first)} → "
f"{fmt_value(m, last)}{m.unit}(Δz={dz:+.1f})")
out += ["", "[各水準で過ごした時間の割合と、最高値・最低値の時刻]"]
for spec in INDEXES:
st = self.index[spec.key]
total = sum(st.level_time)
if total <= 0:
continue
share = "/".join(f"{lv} {tm / total * 100:3.0f}%"
for lv, tm in zip(LEVELS, st.level_time))
out.append(f" ・{pad_display(spec.name, 16)} {share}")
if isnum(st.hi[0]):
out.append(f" 最高 {st.hi[0]:+.2f} ({fmt_clock(st.hi[1])}) "
f"最低 {st.lo[0]:+.2f} ({fmt_clock(st.lo[1])})")
out += ["", "[特徴量] 基準 → 現在(直近60秒の代表値)/ z / 傾き / τb"]
for m in METRICS:
st = self.stats[m.key]
if not isnum(st.now):
continue
z = f"{st.z:+.2f}" if isnum(st.z) else "--"
tau = f"{st.tau:+.2f}" if isnum(st.tau) else "--"
out.append(f" {pad_display(m.name, 28)} {fmt_value(m, st.base):>8s} → "
f"{fmt_value(m, st.now):>8s} {m.unit:<8s} "
f"z={z:>6s} 傾き={fmt_slope(m, st.slope):>8s}{slope_unit(m)} τb={tau:>6s}")
out += ["", "[検出事象]",
f" 瞬目 {self.n_blink_total} 回(うち持続400ms以上 {self.n_long_blinks} 回)/"
f"あくび {self.n_yawn_total} 回"]
out += [f" [{fmt_clock(t)}] {text}" for t, text, _ in self.events]
out += ["", "[所見]"] + [" " + text for text, _, _ in self.findings]
out += ["", "※本レポートは医療診断ではありません。総合指標は未検証の重みによる目安であり、"
"心理状態の測定値ではありません。rPPG の脈拍数は照明・体動の影響を受ける参考値です。",
"=" * 78]
return "\n".join(out)
def record_paths() -> Dict[str, str]:
"""保存する4ファイルのパスを決める(フォルダも作る)。"""
os.makedirs(RECORD_DIR, exist_ok=True)
stamp = time.strftime("%Y%m%d_%H%M%S")
return {"txt": os.path.join(RECORD_DIR, f"レポート_{stamp}.txt"),
"csv": os.path.join(RECORD_DIR, f"計測値_{stamp}.csv"),
"dash": os.path.join(RECORD_DIR, f"画面_{stamp}.png"),
"sum": os.path.join(RECORD_DIR, f"まとめ_{stamp}.png")}
# ==============================================================================
# 10. 計測画面の描画
# ==============================================================================
BAR_H = 30 # パネルの表題帯の高さ
VID_X, VID_Y = 12, 12
TL_Y, TL_H = VID_Y + VIEW_H + 10, 200
EV_Y = TL_Y + TL_H + 8
EV_H = CANVAS_H - EV_Y - 12
PX, PX1 = VID_X + VIEW_W + 12, CANVAS_W - 12
HEAD_Y, HEAD_H = 12, 50
SUM_Y, SUM_H = HEAD_Y + HEAD_H + 8, 70
IDX_Y, IDX_H = SUM_Y + SUM_H + 8, BAR_H + 4 * 44 + 8
TAB_Y = IDX_Y + IDX_H + 8
TAB_H = CANVAS_H - TAB_Y - 12
KIND_COLOR = {"up": C_UP, "down": C_DOWN, "flat": C_TXT, "warn": C_WARN}
Rect = Tuple[int, int, int, int]
class Dashboard:
"""左列(映像・総合指標の推移・イベント)と右列(状態・総合指標・根拠タブ)を1枚に組み上げる。"""
def __init__(self, text: TextLayer) -> None:
self.tl = text
self.page = 0
self.tab = 0
self.show_help = False
self.hits: List[Tuple[Rect, str, int]] = []
self._bg = np.full((CANVAS_H, CANVAS_W, 3), C_BG, np.uint8)
# ------------------------------------------------------------ 部品 ------
def _panel(self, img, x0, y0, x1, y1, title: str, note: str = "") -> None:
fill_box(img, x0, y0, x1, y1, C_PANEL)
cv2.rectangle(img, (x0, y0), (x1, y0 + BAR_H), C_PANEL2, -1)
self.tl.add(x0 + 10, y0 + BAR_H // 2, title, FS_TITLE, C_ACC, "lm")
if note:
room = x1 - x0 - 34 - self.tl.width(title, FS_TITLE)
self.tl.add(x1 - 10, y0 + BAR_H // 2, self.tl.fit(note, FS_BODY, room),
FS_BODY, C_DIM, "rm")
def _button(self, img, x0: int, y0: int, w: int, h: int, label: str,
action: str, arg: int = 0, active: bool = False) -> None:
fill_box(img, x0, y0, x0 + w, y0 + h, C_ACC if active else C_BTN)
self.tl.add(x0 + w // 2, y0 + h // 2, self.tl.fit(label, FS_BODY, w - 10), FS_BODY,
(30, 28, 26) if active else C_TXT, "cm")
self.hits.append(((x0, y0, x0 + w, y0 + h), action, arg))
def _page_buttons(self, img, y: int) -> None:
w = (PX1 - PX - 16 - 3 * 6) // N_PAGES
for i, title in enumerate(PAGE_TITLES):
self._button(img, PX + 8 + i * (w + 6), y, w, 24, f"{i + 1} {title}",
"page", i, active=(i == self.page))
@staticmethod
def _zbar(img, x, y, w, h, z, full: float = 3.0) -> None:
"""中央を 0 とし、±full の範囲で z(または寄与)を示す棒。"""
cx = x + w // 2
cv2.rectangle(img, (x, y), (x + w, y + h), (58, 56, 54), -1)
cv2.line(img, (cx, y), (cx, y + h), (120, 118, 116), 1)
if not isnum(z):
return
length = int(abs(clamp(z / full, -1.0, 1.0)) * (w // 2))
if length > 0:
x_a, x_b = (cx, cx + length) if z >= 0 else (cx - length, cx)
cv2.rectangle(img, (x_a, y), (x_b, y + h), C_UP if z >= 0 else C_DOWN, -1)
def _plot(self, img, x, y, w, h, ts, vs, t0, t1, base=NAN, band=NAN,
lm: int = 58, show_x: bool = True, calib_end: float = NAN) -> None:
"""時系列の折れ線(縦軸目盛り・時刻目盛り・個人基準の点線・基準±1z の帯)。"""
px0, py0, px1, py1 = x + lm, y, x + w, y + h - (18 if show_x else 0)
cv2.rectangle(img, (px0, py0), (px1, py1), C_PLOT, -1)
span = max(t1 - t0, 1e-6)
def xpix(tt: float) -> int:
return int(px0 + clamp((tt - t0) / span, 0.0, 1.0) * (px1 - px0))
if isnum(calib_end) and calib_end > t0:
cv2.rectangle(img, (px0, py0), (xpix(calib_end), py1), C_CALIB, -1)
cand = list(vs)
if isnum(base):
cand += [base] + ([base - band, base + band] if isnum(band) else [])
if cand:
lo, hi = min(cand), max(cand)
if hi - lo < 1e-9:
d = max(abs(lo) * 0.05, 0.01)
lo, hi = lo - d, hi + d
pad = (hi - lo) * 0.1
lo, hi = lo - pad, hi + pad
def ypix(v: float) -> int:
return int(py1 - (v - lo) / (hi - lo) * (py1 - py0))
if isnum(base) and isnum(band):
cv2.rectangle(img, (px0, ypix(base + band)), (px1, ypix(base - band)), C_BAND, -1)
if lm > 0:
ticks, dec = nice_ticks(lo, hi, max(2, (py1 - py0) // 26))
for v in ticks:
yy = ypix(v)
cv2.line(img, (px0, yy), (px1, yy), (48, 46, 44), 1)
self.tl.add(px0 - 4, yy, f"{v:.{dec}f}", FS_TICK, C_DIM, "rm")
if isnum(base):
yb = ypix(base)
for xx in range(px0 + 1, px1 - 2, 6):
cv2.line(img, (xx, yb), (xx + 3, yb), (150, 148, 146), 1)
if ts.size >= 2:
step = max(1, ts.size // 600)
xs = (px0 + np.clip((ts[::step] - t0) / span, 0, 1) * (px1 - px0)).astype(np.int32)
ys = (py1 - (vs[::step] - lo) / (hi - lo) * (py1 - py0)).astype(np.int32)
cv2.polylines(img, [np.stack([xs, ys], 1).reshape(-1, 1, 2)], False,
C_ACC, 1, cv2.LINE_AA)
if ts.size:
cv2.circle(img, (xpix(ts[-1]), ypix(vs[-1])), 3, (255, 255, 255), -1)
if show_x:
for tt in time_ticks(t0, t1, max(2, (px1 - px0) // 80)):
xx = xpix(tt)
cv2.line(img, (xx, py1), (xx, py1 + 3), C_DIM, 1)
self.tl.add(xx, py1 + 3, fmt_clock(tt), FS_TICK, C_DIM, "ct")
cv2.rectangle(img, (px0, py0), (px1, py1), (72, 70, 68), 1)
def _metric_plot(self, img, an: Analyzer, m: MetricSpec, x: int, y: int, w: int, h: int,
t0: float, t1: float, **kw) -> None:
"""特徴量の推移を表示単位で描く(個人基準の点線と基準±1z の帯つき)。"""
st = an.stats[m.key]
ts, vs = an.smoothed_window(m, t1 - t0 + 1.0, t1)
band = an.band_of(m) * m.scale if isnum(st.base) else NAN
self._plot(img, x, y, w, h, ts, vs * m.scale, t0, t1, st.base * m.scale, band, **kw)
def _level_bar(self, img, x, y, w, h, spec: IndexSpec, level_time: Sequence[float]) -> None:
"""各水準で過ごした時間の割合を1本の帯で示す(明るいほど高い水準)。"""
cv2.rectangle(img, (x, y), (x + w, y + h), (58, 56, 54), -1)
total = sum(level_time)
if total <= 0:
self.tl.add(x + w // 2, y + h // 2, "記録なし", FS_BODY, C_DIM, "cm")
return
cx = x
for i, tm in enumerate(level_time):
seg = int(round(w * tm / total))
if seg <= 0:
continue
shade = 0.42 + 0.19 * i
color = tuple(int(clamp(c * shade, 0, 255)) for c in spec.color)
cv2.rectangle(img, (cx, y), (min(cx + seg, x + w), y + h), color, -1)
if seg >= 90:
self.tl.add(cx + seg // 2, y + h // 2, f"{LEVELS[i]} {tm / total * 100:.0f}%",
FS_BODY, (24, 22, 20), "cm")
cx += seg
cv2.rectangle(img, (x, y), (x + w, y + h), C_LINE, 1)
# -------------------------------------------------------- 画面の構築 ----
def build(self, an: Analyzer, state: Dict[str, Any]) -> np.ndarray:
img = self._bg.copy()
self.hits = []
self._timeline(img, an)
self._events(img, an)
self._header(img, an, state)
self._summary(img, an)
self._indexes(img, an)
self._tabs(img, an)
img = self.tl.flush(img)
if self.show_help: # ヘルプは最前面に重ねる
self._help(img)
img = self.tl.flush(img)
return img
# ------------------------------------------------------------ 各部 ------
def _header(self, img, an: Analyzer, state: Dict[str, Any]) -> None:
x0, y0, x1, y1 = PX, HEAD_Y, PX1, HEAD_Y + HEAD_H
fill_box(img, x0, y0, x1, y1, C_PANEL2)
cy = (y0 + y1) // 2
self.tl.add(x0 + 12, cy, "顔特徴トレンド・モニタ", 18, C_ACC, "lm")
q, cov, hr = (an.stats[k].now for k in ("quality", "coverage", "hr"))
info = (f"経過 {fmt_clock(an.t_now)} FPS {state['fps']:.1f} "
f"画像品質 {q if isnum(q) else 0:.2f} "
f"有効フレーム率 {(cov if isnum(cov) else 0) * 100:3.0f}% "
f"脈拍数(rPPG参考) {f'{hr:.0f}' if isnum(hr) else '--'} bpm ※いずれも直近60秒")
self.tl.add(x1 - 12, cy - 11, self.tl.fit(info, FS_BODY, x1 - x0 - 230), FS_BODY, C_TXT, "rm")
if an.calibrated:
note, color = "個人基準: 校正済み", C_OK
else:
ratio = state["calib"] or 0.0
note = (f"個人基準を校正中 {ratio * 100:3.0f}%" if ratio < 1.0
else "個人基準を校正中(有効な1秒値が10個そろうのを待っています)")
color = C_WARN
if state["speed"]:
note += f" 再生 {state['speed']:g}倍速"
if state["paused"]:
note += " 一時停止中"
note += " 警告音 " + ("入" if state["sound"] else "切")
self.tl.add(x1 - 12, cy + 12, note, FS_BODY, color, "rm")
def _summary(self, img, an: Analyzer) -> None:
x0, y0, x1, y1 = PX, SUM_Y, PX1, SUM_Y + SUM_H
head, detail, color = an.summary
fill_box(img, x0, y0, x1, y1, C_PANEL, color)
cv2.rectangle(img, (x0, y0), (x0 + 6, y1), color, -1)
self.tl.add(x0 + 14, y0 + 13,
"現在の総合指標の水準と傾向(個人基準との比較であり、心理状態の診断ではありません)",
FS_BODY, C_DIM, "lm")
self.tl.add(x0 + 18, y0 + 36, self.tl.fit(head, 18, x1 - x0 - 36), 18, color, "lm")
self.tl.add(x0 + 18, y0 + 58, self.tl.fit(detail, FS_BODY, x1 - x0 - 36),
FS_BODY, C_TXT, "lm")
def _indexes(self, img, an: Analyzer) -> None:
self._panel(img, PX, IDX_Y, PX1, IDX_Y + IDX_H,
"総合指標(ロバスト z を未検証の重みで平均した目安)",
"棒: −2〜+2、中央線=0(個人基準)")
for i, spec in enumerate(INDEXES):
y = IDX_Y + BAR_H + 4 + i * 44
st = an.index[spec.key]
self.tl.add(PX + 12, y + 12, spec.name, FS_TITLE, C_TXT, "lm")
bx = PX + 160
if not isnum(st.value):
self.tl.add(bx, y + 12, "校正の完了と特徴量の算出を待っています…",
FS_BODY, C_DIM, "lm")
continue
color = index_color(spec, st.value)
self._bar_value(img, bx, y + 4, 200, 16, st.value, color)
self.tl.add(bx + 212, y + 12, f"{st.value:+.2f}", FS_TITLE, C_TXT, "lm")
self.tl.add(bx + 272, y + 12, f"[{LEVELS[st.level]}]", FS_LABEL, color, "lm")
trend = (f"{trend_arrow(st.tau)} 傾き {st.slope:+.3f}/分 τb={st.tau:+.2f}(180秒)"
if isnum(st.slope) else "傾き・τb: 記録90秒未満のため未算出")
self.tl.add(bx + 372, y + 12, trend, FS_BODY, C_DIM, "lm")
detail = " ".join(f"{METRIC_MAP[k].name} z={z:+.1f}(寄与 {p:+.2f})"
for k, p, z in st.contrib)
self.tl.add(PX + 12, y + 33, self.tl.fit("寄与上位: " + detail, FS_BODY, PX1 - PX - 24),
FS_BODY, C_DIM, "lm")
@staticmethod
def _bar_value(img, x, y, w, h, value, color) -> None:
"""−2〜+2 の値を左端からの棒で示す(中央の縦線が 0)。"""
cv2.rectangle(img, (x, y), (x + w, y + h), (62, 60, 58), -1)
filled = int(clamp((value + 2.0) / 4.0, 0.0, 1.0) * w)
if filled > 0:
cv2.rectangle(img, (x, y), (x + filled, y + h), color, -1)
cv2.line(img, (x + w // 2, y - 2), (x + w // 2, y + h + 2), (200, 198, 196), 1)
# ------------------------------------------------------ 根拠のタブ ------
def _tabs(self, img, an: Analyzer) -> None:
fill_box(img, PX, TAB_Y, PX1, TAB_Y + TAB_H, C_PANEL)
cv2.rectangle(img, (PX, TAB_Y), (PX1, TAB_Y + BAR_H), C_PANEL2, -1)
for i, title in enumerate(TAB_TITLES):
self._button(img, PX + 8 + i * 166, TAB_Y + 3, 160, 24, title, "tab", i,
active=(i == self.tab))
self.tl.add(PX1 - 10, TAB_Y + BAR_H // 2, "T キーでも切替", FS_BODY, C_DIM, "rm")
if not an.calibrated and self.tab < 2:
self.tl.add(PX + 12, TAB_Y + BAR_H + 24,
"個人基準を校正しています。校正が完了すると z と所見を表示します。",
FS_BODY, C_WARN, "lm")
return
(self._tab_findings, self._tab_breakdown, self._tab_series, self._tab_table)[self.tab](img, an)
def _note(self, y: int, text: str) -> None:
self.tl.add(PX + 12, y, self.tl.fit(text, FS_BODY, PX1 - PX - 24), FS_BODY, C_DIM, "lm")
def _tab_findings(self, img, an: Analyzer) -> None:
y = TAB_Y + BAR_H + 14
self._note(y, "選定: 総合指標の構成特徴量のうち |z|≥0.9 または |τb|≥0.32。"
"グラフ: 直近4分、点線=個人基準、帯=基準±1z(1.4826×MAD、下限あり)")
y += 18
items = an.findings
n_plot = sum(1 for _, key, _ in items if key)
rh = min(118, (TAB_Y + TAB_H - 6 - y - 24 * (len(items) - n_plot)) // max(n_plot, 1))
t1 = an.t_now
t0 = max(an.t0, t1 - SPARK_SEC)
for text, key, kind in items:
self.tl.add(PX + 12, y + 11, self.tl.fit(text, FS_BODY, PX1 - PX - 24),
FS_BODY, KIND_COLOR[kind], "lm")
if key is None:
y += 24
continue
self._metric_plot(img, an, METRIC_MAP[key], PX + 12, y + 22, PX1 - PX - 30, rh - 26,
t0, t1, calib_end=an.calib_end)
y += rh
def _tab_breakdown(self, img, an: Analyzer) -> None:
y = TAB_Y + BAR_H + 14
self._note(y, "指標値 = 15秒の指数平滑化[ Σ wᵢ·clip(zᵢ, −3, +3) ÷ Σ|wᵢ| ]"
"(Σ は z が得られた成分のみ。重み w は経験的に定めた未検証の値)")
top = y + 16
cw = (PX1 - PX - 24) // 2
ch = (TAB_Y + TAB_H - 6 - top) // 2
for n, spec in enumerate(INDEXES):
st = an.index[spec.key]
x0, y0 = PX + 8 + (n % 2) * (cw + 8), top + (n // 2) * ch
cv2.rectangle(img, (x0, y0), (x0 + cw, y0 + ch - 4), C_ROW, -1)
head = (f"{spec.name} 平滑後 {st.value:+.2f}/平滑前 {st.raw:+.2f} [{LEVELS[st.level]}]"
f" 重みの充足率 {st.coverage * 100:.0f}%" if isnum(st.value)
else f"{spec.name} 未算出(z が得られた成分の重みが60%未満)")
self.tl.add(x0 + 6, y0 + 11, self.tl.fit(head, FS_LABEL, cw - 12), FS_LABEL,
spec.color, "lm")
cols = (("特徴量", x0 + 6, "lm"), ("w", x0 + 216, "rm"), ("z", x0 + 266, "rm"),
("w·clip(z)(±1)", x0 + 342, "cm"), ("寄与", x0 + cw - 6, "rm"))
for label, x, anchor in cols:
self.tl.add(x, y0 + 30, label, FS_BODY, C_DIM, anchor)
rh = (ch - 46) // max(len(spec.comps), 1)
yy = y0 + 42
for key, w, z, part in (st.parts or [(k, w, NAN, NAN) for k, w in spec.comps]):
cy = yy + rh // 2
self.tl.add(x0 + 6, cy, self.tl.fit(METRIC_MAP[key].name, FS_BODY, 170),
FS_BODY, C_TXT, "lm")
self.tl.add(x0 + 216, cy, f"{w:+.2f}", FS_BODY, C_TXT, "rm")
self.tl.add(x0 + 266, cy, f"{z:+.1f}" if isnum(z) else "--", FS_BODY,
C_TXT if isnum(z) else C_DIM, "rm")
self._zbar(img, x0 + 282, cy - 6, 120, 12, part, full=1.0)
self.tl.add(x0 + cw - 6, cy, f"{part:+.3f}" if isnum(part) else "--",
FS_BODY, C_TXT, "rm")
yy += rh
def _tab_series(self, img, an: Analyzer) -> None:
y = TAB_Y + BAR_H + 6
self._page_buttons(img, y)
self._note(y + 38, "横軸: 経過時刻 mm:ss(セッション全体)/点線: 個人基準/帯: 基準±1z"
"(1.4826×MAD)/●: 最新の1秒値/割合量は15秒移動平均")
top = y + 52
cw = (PX1 - PX - 24) // 2
ch = (TAB_Y + TAB_H - 6 - top) // 4
t0 = an.t0
t1 = max(an.t_now, t0 + 60.0)
for i, m in enumerate(PAGE_METRICS[self.page]):
st = an.stats[m.key]
x0, y0 = PX + 8 + (i % 2) * (cw + 8), top + (i // 2) * ch
z = f"z={st.z:+.1f}" if isnum(st.z) else "z=--"
title = (f"{m.name}[{m.unit or '無次元'}] 現在 {fmt_value(m, st.now)} "
f"基準 {fmt_value(m, st.base)} {z}")
self.tl.add(x0, y0 + 9, self.tl.fit(title, FS_BODY, cw), FS_BODY, C_TXT, "lm")
self._metric_plot(img, an, m, x0, y0 + 20, cw, ch - 24, t0, t1,
calib_end=an.calib_end)
def _tab_table(self, img, an: Analyzer) -> None:
self._page_buttons(img, TAB_Y + BAR_H + 6)
cols = dict(name=PX + 12, now=PX + 336, base=PX + 414, z=PX + 462,
zbar=PX + 474, slope=PX + 578, spark=PX + 760)
hy = TAB_Y + BAR_H + 50
for text, x, anchor in (("特徴量(定義・解釈)", cols["name"], "lm"),
("現在(60秒)", cols["now"], "rm"),
("基準", cols["base"], "rm"), ("z", cols["z"], "rm"),
("z(±3)", cols["zbar"] + 45, "cm"),
("傾き(180秒)・τb", cols["slope"], "lm"),
("直近4分・点線=基準・帯=±1z", cols["spark"], "lm")):
self.tl.add(x, hy, self.tl.fit(text, FS_BODY, PX1 - 10 - x if x == cols["spark"] else 200),
FS_BODY, C_DIM, anchor)
cv2.line(img, (PX + 8, hy + 12), (PX1 - 8, hy + 12), C_LINE, 1)
rows = PAGE_METRICS[self.page]
y = hy + 16
rh = min(52, (TAB_Y + TAB_H - 6 - y) // max(len(rows), 1))
t1 = an.t_now
t0 = t1 - SPARK_SEC
for i, m in enumerate(rows):
st = an.stats[m.key]
cy = y + rh // 2
if i % 2 == 1:
cv2.rectangle(img, (PX + 6, y + 1), (PX1 - 6, y + rh - 1), C_ROW, -1)
self.tl.add(cols["name"], cy - 10, self.tl.fit(m.name, FS_LABEL, 300), FS_LABEL,
C_TXT, "lm")
self.tl.add(cols["name"] + 4, cy + 11, self.tl.fit(m.hint, FS_BODY, 296), FS_BODY,
(140, 138, 136), "lm")
self.tl.add(cols["now"], cy, f"{fmt_value(m, st.now)}{m.unit}", FS_LABEL, C_TXT, "rm")
self.tl.add(cols["base"], cy, fmt_value(m, st.base), FS_BODY, C_DIM, "rm")
color = C_DIM
if isnum(st.z):
color = (C_BAD if st.z >= 2.0 else C_WARN) if abs(st.z) >= 1.0 else C_TXT
self.tl.add(cols["z"], cy, f"{st.z:+.1f}" if isnum(st.z) else "--", FS_LABEL, color, "rm")
self._zbar(img, cols["zbar"], cy - 8, 90, 16, st.z)
if isnum(st.slope):
arrow = trend_arrow(st.tau)
self.tl.add(cols["slope"], cy - 10, f"{arrow} {fmt_slope(m, st.slope)}{slope_unit(m)}",
FS_BODY, C_TXT if arrow != "→" else C_DIM, "lm")
self.tl.add(cols["slope"] + 16, cy + 11, f"τb={st.tau:+.2f}", FS_BODY, C_DIM, "lm")
else:
self.tl.add(cols["slope"], cy, "--(90秒未満)" if m.analyze else "対象外",
FS_BODY, C_DIM, "lm")
self._metric_plot(img, an, m, cols["spark"], y + 5, PX1 - 12 - cols["spark"], rh - 10,
t0, t1, lm=0, show_x=False)
y += rh
# ----------------------------------------------------------- 左列 -------
def _timeline(self, img, an: Analyzer) -> None:
x0, x1 = VID_X, VID_X + VIEW_W
self._panel(img, x0, TL_Y, x1, TL_Y + TL_H, "総合指標の推移(0=個人基準、未検証の重みによる目安)")
px0, py0, px1, py1 = x0 + 46, TL_Y + BAR_H + 8, x1 - 20, TL_Y + TL_H - 52
cv2.rectangle(img, (px0, py0), (px1, py1), C_PLOT, -1)
lo, hi = -2.0, 3.0
t0 = an.t0
t1 = max(an.t_now, t0 + 60.0)
def ypix(v: float) -> int:
return int(py1 - (clamp(v, lo, hi) - lo) / (hi - lo) * (py1 - py0))
def xpix(t: float) -> int:
return int(px0 + clamp((t - t0) / (t1 - t0), 0.0, 1.0) * (px1 - px0))
if isnum(an.calib_end):
cv2.rectangle(img, (px0, py0), (max(xpix(an.calib_end), px0 + 1), py1), C_CALIB, -1)
self.tl.add(px0 + 4, py1 - 10, "校正", FS_TICK, C_DIM, "lm")
cv2.rectangle(img, (px0, ypix(0.6)), (px1, ypix(-0.6)), C_BAND, -1)
for v in range(-2, 4):
yy = ypix(v)
cv2.line(img, (px0, yy), (px1, yy), (110, 108, 106) if v == 0 else (52, 50, 48), 1)
self.tl.add(px0 - 5, yy, f"{v:+d}" if v else "0", FS_TICK, C_DIM, "rm")
yy = ypix(1.4)
for xx in range(px0, px1 - 4, 8):
cv2.line(img, (xx, yy), (xx + 4, yy), (80, 90, 150), 1)
self.tl.add(px0 + 4, ypix(0) - 9, "0=個人基準", FS_TICK, C_DIM, "lm")
self.tl.add(px1 - 4, py0 + 9, "帯: ±0.6(基準付近) 破線: +1.4(高い) 縦棒: 事象",
FS_TICK, C_DIM, "rm")
for spec in INDEXES:
data = list(an.idx_series[spec.key])
if len(data) < 2:
continue
step = max(1, len(data) // 600)
pts = [(xpix(t), ypix(v)) for t, v in data[::step]]
cv2.polylines(img, [np.asarray(pts, np.int32).reshape(-1, 1, 2)], False,
spec.color, 1, cv2.LINE_AA)
for t, color in an.marks:
xx = xpix(t)
cv2.line(img, (xx, py1 - 7), (xx, py1), color, 2)
for tt in time_ticks(t0, t1, 7):
xx = xpix(tt)
cv2.line(img, (xx, py1), (xx, py1 + 3), C_DIM, 1)
self.tl.add(xx, py1 + 4, fmt_clock(tt), FS_TICK, C_DIM, "ct")
cv2.rectangle(img, (px0, py0), (px1, py1), (72, 70, 68), 1)
lx, ly = x0 + 12, TL_Y + TL_H - 14
for spec in INDEXES:
v = an.index[spec.key].value
label = f"{spec.name} {v:+.2f}" if isnum(v) else f"{spec.name} --"
cv2.line(img, (lx, ly), (lx + 14, ly), spec.color, 3)
self.tl.add(lx + 18, ly, label, FS_BODY, C_TXT, "lm")
lx += 32 + self.tl.width(label, FS_BODY)
def _events(self, img, an: Analyzer) -> None:
x1 = VID_X + VIEW_W
self._panel(img, VID_X, EV_Y, x1, EV_Y + EV_H, "事象・水準遷移の記録")
buttons = (("ヘルプ H", "help"), ("目印 E", "mark"), ("保存 S", "save"), ("再校正 C", "calib"))
for i, (label, action) in enumerate(buttons):
self._button(img, x1 - 10 - (len(buttons) - i) * 90, EV_Y + 3, 84, 24, label, action,
active=(action == "help" and self.show_help))
y = EV_Y + BAR_H + 14
shown: List[Tuple[str, Tuple[int, int, int]]] = []
for t, text, color in list(an.events)[-14:]:
for i, line in enumerate(self.tl.wrap(f"[{fmt_clock(t)}] " + text, FS_BODY,
VIEW_W - 34, 2)):
shown.append(((" " * 8 + line) if i else line, color))
for line, color in shown[-max(1, (EV_Y + EV_H - 8 - y) // 20 + 1):]:
self.tl.add(VID_X + 12, y, line, FS_BODY, color, "lm")
y += 20
def _help(self, img) -> None:
"""ヘルプを最前面に重ねる(項目名の列と、折り返した説明の列)。"""
x0, y0, x1 = PX + 8, HEAD_Y + HEAD_H + 8, PX1 - 8
lx = x0 + 18
tx = lx + HELP_LABEL_W
tw = x1 - 18 - tx
rows: List[Tuple[int, str, str, bool]] = [] # (y, 項目名, 本文, 見出しか)
y = y0 + 22
for n, (title, items) in enumerate(HELP_SECTIONS):
if n:
y += 6
rows.append((y, "", "■ " + title, True))
y += 24
for label, text in items:
for i, line in enumerate(self.tl.wrap(text, FS_BODY, tw, 4)):
rows.append((y, label if i == 0 else "", line, False))
y += 21
y1 = y + 26
cv2.rectangle(img, (x0, y0), (x1, y1), (32, 30, 34), -1)
cv2.rectangle(img, (x0, y0), (x1, y1), C_ACC, 2)
for yy, label, text, head in rows:
if head:
self.tl.add(lx, yy, text, FS_LABEL, C_ACC, "lm")
continue
if label:
self.tl.add(lx + 8, yy, label, FS_BODY, C_UP, "lm")
self.tl.add(tx, yy, text, FS_BODY, C_TXT, "lm")
self.tl.add(x1 - 16, y1 - 14, "H キーまたは「ヘルプ H」ボタンで閉じます", FS_BODY, C_DIM, "rm")
# ---------------------------------------------------- まとめの1枚 ------
def summary_sheet(self, an: Analyzer, paths: Dict[str, str]) -> np.ndarray:
"""計測の終了時に表示する振り返りの画面。"""
img = np.full((CANVAS_H, CANVAS_W, 3), C_BG, np.uint8)
cv2.rectangle(img, (0, 0), (CANVAS_W, 60), C_PANEL2, -1)
self.tl.add(28, 30, "セッションのまとめ", 26, C_ACC, "lm")
self.tl.add(CANVAS_W - 28, 30,
f"計測 {an.elapsed / 60.0:.1f} 分 個人基準 {'校正済み' if an.calibrated else '未完了'} "
+ time.strftime("%Y-%m-%d %H:%M"), FS_LABEL, C_TXT, "rm")
lx0, lx1 = 20, 800
self._panel(img, lx0, 72, lx1, 432, "総合指標: 水準別の滞在時間と前半1/3→後半1/3の平均",
"帯の長さ=時間の割合、明るいほど高い水準")
arcs = {spec.key: (a, b) for spec, a, b in an.index_arcs()}
y = 108
for spec in INDEXES:
st = an.index[spec.key]
self.tl.add(lx0 + 14, y + 10, spec.name, 17, C_TXT, "lm")
arc = arcs.get(spec.key)
if arc is None:
self.tl.add(lx0 + 170, y + 10, "記録が24秒分未満のため比較できません", FS_BODY, C_DIM, "lm")
else:
first, last = arc
self.tl.add(lx0 + 170, y + 10, f"{first:+.2f} → {last:+.2f}({last - first:+.2f})"
f"{change_word(last - first, 0.25)}", FS_LABEL, index_color(spec, last), "lm")
if isnum(st.hi[0]):
self.tl.add(lx1 - 16, y + 10, f"最高 {st.hi[0]:+.2f} ({fmt_clock(st.hi[1])})/"
f"最低 {st.lo[0]:+.2f} ({fmt_clock(st.lo[1])})", FS_BODY, C_DIM, "rm")
self._level_bar(img, lx0 + 14, y + 26, lx1 - lx0 - 28, 26, spec, st.level_time)
y += 80
self._panel(img, lx0, 444, lx1, 668, "変化の大きかった特徴量",
"Δz = (後半1/3の平均 − 前半1/3の平均) ÷ (1.4826×MAD)")
y = 490
rows = an.metric_arcs()[:6]
if not rows:
self.tl.add(lx0 + 14, y, "比較できる長さの記録がありません。", FS_BODY, C_DIM, "lm")
for m, first, last, dz in rows:
self.tl.add(lx0 + 14, y, self.tl.fit(m.name, FS_LABEL, 270), FS_LABEL, C_TXT, "lm")
self.tl.add(lx0 + 290, y, f"{fmt_value(m, first)} → {fmt_value(m, last)}{m.unit}",
FS_LABEL, C_TXT, "lm")
self._zbar(img, lx0 + 480, y - 8, 120, 16, dz)
self.tl.add(lx0 + 612, y, f"Δz={dz:+.1f} {change_word(dz, 0.4)}", FS_BODY,
C_UP if dz >= 0 else C_DOWN, "lm")
y += 30
rx0, rx1 = 812, CANVAS_W - 20
self._panel(img, rx0, 72, rx1, 224, "検出した事象")
minutes = max(an.elapsed / 60.0, 1e-6)
y = 108
for line in (f"瞬目 {an.n_blink_total} 回(計測時間全体の平均 {an.n_blink_total / minutes:.1f} 回/分)",
f"うち持続400ms以上の瞬目 {an.n_long_blinks} 回",
f"あくび {an.n_yawn_total} 回",
f"総合指標の水準の切り替わり {len(an.transitions)} 回"):
self.tl.add(rx0 + 14, y, line, FS_LABEL, C_TXT, "lm")
y += 28
self._panel(img, rx0, 236, rx1, 668, "水準が切り替わった時刻(直近14件)")
y = 272
items = list(an.transitions)[-14:]
if not items:
self.tl.add(rx0 + 14, y, "水準の切り替わりはありませんでした。", FS_BODY, C_DIM, "lm")
for t, head in items:
self.tl.add(rx0 + 14, y, self.tl.fit(f"[{fmt_clock(t)}] {head}", FS_BODY, rx1 - rx0 - 28),
FS_BODY, C_TXT, "lm")
y += 28
self._panel(img, lx0, 680, rx1, 830, "最後の所見と保存したファイル",
"総合指標は未検証の重みによる目安であり、心理状態の診断ではありません")
y = 718
for text, _, _ in an.findings[:3]:
self.tl.add(lx0 + 14, y, self.tl.fit(text, FS_BODY, rx1 - lx0 - 28), FS_BODY, C_TXT, "lm")
y += 24
self.tl.add(lx0 + 14, 792, "保存先: " + os.path.join(RECORD_DIR, ""), FS_BODY, C_DIM, "lm")
self.tl.add(lx0 + 14, 814, " ".join(os.path.basename(paths[k])
for k in ("txt", "csv", "dash", "sum")), FS_BODY, C_ACC, "lm")
self.tl.add(CANVAS_W // 2, CANVAS_H - 15,
"何かキーを押すと終了します(この画面も PNG で保存しました)", FS_LABEL, C_OK, "cm")
return self.tl.flush(img)
# ==============================================================================
# 11. 映像への重ね描き
# ==============================================================================
def draw_overlay(view: np.ndarray, feat: Optional[Dict[str, Any]], vmap: ViewMap,
state: Dict[str, Any], tl: TextLayer) -> np.ndarray:
"""表示用に縮小した映像へ、解析結果を座標変換して重ねる。"""
h, w = view.shape[:2]
shade = view.copy()
cv2.rectangle(shade, (0, 0), (w, 28), (18, 18, 18), -1)
cv2.rectangle(shade, (0, h - 34), (w, h), (18, 18, 18), -1)
img = cv2.addWeighted(shade, 0.55, view, 0.45, 0)
if feat is None:
tl.add(w // 2, h // 2, "顔が検出されていません", 22, C_BAD, "cm")
else:
pts = feat["points"]
for contour in DRAW_CONTOURS:
poly = np.asarray([vmap.pt(pts[i][0], pts[i][1]) for i in contour], np.int32)
cv2.polylines(img, [poly.reshape(-1, 1, 2)], False, (110, 200, 120), 1, cv2.LINE_AA)
if state["rppg"]:
for bx0, by0, bx1, by1 in feat["rois"]:
cv2.rectangle(img, vmap.pt(bx0, by0), vmap.pt(bx1, by1), (90, 170, 250), 1)
# 頭部座標系の3軸(赤: 左右、緑: 上下、青: 前後)
nose = vmap.pt(pts[1][0], pts[1][1])
length = max(30.0, 0.9 * feat["iod"] * vmap.scale)
for col_idx, color in ((0, (80, 80, 255)), (1, (80, 255, 80)), (2, (255, 160, 60))):
axis = feat["rot"][:, col_idx]
tip = (int(nose[0] + axis[0] * length), int(nose[1] - axis[1] * length))
cv2.arrowedLine(img, nose, tip, color, 2, cv2.LINE_AA, tipLength=0.25)
closure = feat["closure"]
cv2.rectangle(img, (10, h - 24), (130, h - 12), (70, 70, 70), -1)
cv2.rectangle(img, (10, h - 24), (10 + int(clamp(closure, 0, 1) * 120), h - 12),
C_WARN if closure < 0.8 else C_BAD, -1)
tl.add(138, h - 18, f"閉眼度 {closure:.2f}(0.80以上を閉眼として PERCLOS に算入)",
FS_BODY, C_TXT, "lm")
tl.add(w - 10, h - 44, f"ヨー {feat['yaw']:+5.1f}° ピッチ {feat['pitch']:+5.1f}° "
f"ロール {feat['roll']:+5.1f}°", FS_BODY, C_DIM, "rm")
if state["blink_flash"] > 0:
tl.add(w - 14, 14, "瞬目", FS_TITLE, C_UP, "rm")
if state["yawn_flash"] > 0:
tl.add(w - 70, 14, "あくび", FS_TITLE, C_WARN, "rm")
tl.add(10, 14, f"FPS {state['fps']:.1f} 画像品質 {state['quality']:.2f}", FS_BODY, C_TXT, "lm")
if state["paused"]:
tl.add(w // 2, 14, "一時停止", FS_TITLE, C_WARN, "cm")
ratio = state["calib"]
if ratio is not None:
img = tint_rows(img, h - 112, h - 40, (52, 44, 24), 0.80)
bx0, bw = 24, w - 48
cv2.rectangle(img, (bx0, h - 62), (bx0 + bw, h - 50), (72, 68, 64), -1)
cv2.rectangle(img, (bx0, h - 62), (bx0 + int(bw * clamp(ratio, 0, 1)), h - 50), C_ACC, -1)
tl.add(w // 2, h - 90, f"個人基準を記録しています {ratio * 100:3.0f}% "
"普段どおりの姿勢で、正面を向いてお待ちください", FS_TITLE,
(250, 236, 210), "cm")
if state["alert"]:
img = tint_rows(img, h - 78, h - 34, (40, 40, 150), 0.75)
tl.add(w // 2, h - 56, "眠気関連指標が「高い」水準です。休憩を検討してください。", 18,
(235, 235, 255), "cm")
if state["mark_flash"]:
tl.add(w // 2, h // 2 - 60, "目印をつけました", 20, C_ACC, "cm")
img = tl.flush(img)
cv2.rectangle(img, (0, 0), (w - 1, h - 1), (92, 90, 88), 1)
return img
# ==============================================================================
# 12. アプリケーション
# ==============================================================================
SPEEDS = (1.0, 2.0, 4.0)
WINDOW = "Face Trend Monitor" # OpenCV のウィンドウ名は ASCII にする(Windows での文字化け防止)
PACE_RESYNC = 0.5 # 解析が実時間からこの秒数以上遅れたら、再生の基準時刻を取り直す
HR_CONF_MIN = 0.45 # 脈拍数を採用するスペクトル集中度の下限
class App:
CHAR_ACTIONS = {"q": "quit", "c": "calib", "p": "next_page", " ": "pause",
"h": "help", "m": "mirror", "f": "speed", "s": "save",
"a": "sound", "e": "mark", "t": "next_tab"}
CODE_ACTIONS = {27: "quit", 9: "next_page"}
def __init__(self, cfg: Config) -> None:
self.cfg = cfg
self.text = TextLayer(FONT_PATH)
self.extractor = FrameExtractor()
self.blink = BlinkDetector()
self.yawn = YawnDetector()
self.rppg = RPPG()
self.an = Analyzer(cfg.calib_sec)
self.dash = Dashboard(self.text)
self.is_file = cfg.kind in ("file", "demo")
self.cap = cfg.cap
self.landmarker = mp_vision.FaceLandmarker.create_from_options(
mp_vision.FaceLandmarkerOptions(
base_options=mp_tasks.BaseOptions(model_asset_path=MODEL_PATH),
running_mode=mp_vision.RunningMode.VIDEO, num_faces=1,
min_face_detection_confidence=0.5, min_face_presence_confidence=0.5,
min_tracking_confidence=0.5, output_face_blendshapes=True,
output_facial_transformation_matrixes=True))
fps = self.cap.get(cv2.CAP_PROP_FPS)
self.video_fps = fps if 1.0 < fps < 240.0 else 30.0
self.speed_i = 0
self.lost_frames = 0
self.loop_offset = 0.0
self.t_cur = 0.0
self.wall0 = time.perf_counter()
self.pace_wall, self.pace_t = self.wall0, 0.0
self.last_ts_ms = -1
self.fps = 0.0
self._fps_t, self._fps_n = self.wall0, 0
self._frame_sig = -1
self.paused = False
self.running = True
self.fresh = True
self.blink_flash = self.yawn_flash = self.mark_flash = 0
self.canvas = np.full((CANVAS_H, CANVAS_W, 3), C_BG, np.uint8)
self.image = np.zeros((VIEW_H, VIEW_W, 3), np.uint8)
self.feat: Optional[Dict[str, Any]] = None
self.panel = self.dash.build(self.an, self._state())
# -------------------------------------------------------- 主ループ ------
def run(self) -> None:
w, h, x, y = window_geometry()
cv2.namedWindow(WINDOW, cv2.WINDOW_NORMAL)
cv2.resizeWindow(WINDOW, w, h)
cv2.moveWindow(WINDOW, x, y)
cv2.setMouseCallback(WINDOW, self._on_mouse)
self.an.add_event(0.0, "計測を開始しました", C_OK)
while self.running:
self._handle_key(cv2.waitKey(1) & 0xFF)
if not self.running or cv2.getWindowProperty(WINDOW, cv2.WND_PROP_VISIBLE) < 1:
break
if self.paused:
time.sleep(0.03)
elif not self._step():
break
if self.fresh:
cv2.imshow(WINDOW, self._compose())
self._shutdown()
def _reset_detectors(self) -> None:
self.extractor.reset()
self.blink.reset()
self.yawn.reset()
self.rppg.reset()
def _resync_pace(self) -> None:
"""再生速度の基準時刻を現在に合わせる(一時停止・速度変更の直後)。"""
self.pace_wall, self.pace_t = time.perf_counter(), self.t_cur
# -------------------------------------------------- 1フレームの処理 ------
def _read(self) -> Tuple[bool, Optional[np.ndarray]]:
"""1フレームを読む。動画は末尾で先頭へ戻り、カメラは100回連続で失敗したら終える。"""
ok, frame = self.cap.read()
if ok:
self.lost_frames = 0
return True, frame
if not self.is_file:
self.lost_frames += 1
time.sleep(0.05)
return self.lost_frames < 100, None
self.loop_offset = self.t_cur + 1.0 / self.video_fps
self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
self._reset_detectors()
self.an.add_event(self.loop_offset, "動画の先頭へ戻りました(計測は継続)", C_DIM)
return self.cap.read()
def _step(self) -> bool:
ok, frame = self._read()
if frame is None:
self.fresh = False
return ok
# DirectShow は新しいフレームを待たずに直前のバッファを返すことがあるため、
# 同一画像の二重解析を避ける(頭部の角速度などが過小になるのを防ぐ)
if not self.is_file:
sig = int(frame[::16, ::16, 1].sum(dtype=np.int64))
if sig == self._frame_sig:
self.fresh = False
time.sleep(0.002)
return True
self._frame_sig = sig
self.fresh = True
if self.cfg.mirror:
frame = cv2.flip(frame, 1)
self.image = shrink_to_width(frame, ANALYZE_W)
if self.is_file:
t = self.loop_offset + self.cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
self._pace(t)
else:
t = time.perf_counter() - self.wall0
self.t_cur = t
# VIDEO モードは単調増加の時刻印を要求するため、1ms 以上ずつ増やす
self.last_ts_ms = max(self.last_ts_ms + 1, int(t * 1000.0))
result = self.landmarker.detect_for_video(
mp.Image(image_format=mp.ImageFormat.SRGB,
data=cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)), self.last_ts_ms)
self.feat = self.extractor.process(result, self.image, t)
hr, hr_conf = NAN, 0.0
if self.feat is not None:
dur = self.blink.update(t, self.feat["closure"])
if dur is not None:
self.an.note_blink(t, dur)
self.blink_flash = 8
dur = self.yawn.update(t, self.feat["jaw_open"])
if dur is not None:
self.an.note_yawn(t, dur)
self.yawn_flash = 45
if self.cfg.use_rppg and self.feat["quality"] >= QUALITY_MIN:
self.rppg.push(t, self.image, self.feat["rois"], self.feat["head_speed"])
hr, hr_conf = self.rppg.estimate(t)
if hr_conf < HR_CONF_MIN: # 集中度の低い推定値は、基準にも現在値にも含めない
hr = NAN
self.blink_flash = max(0, self.blink_flash - 1)
self.yawn_flash = max(0, self.yawn_flash - 1)
self.mark_flash = max(0, self.mark_flash - 1)
self._update_fps()
if self.an.add_frame(self.feat, t, hr, hr_conf):
self.panel = self.dash.build(self.an, self._state())
if self.an.pending_alert:
self.an.pending_alert = False
if self.cfg.sound:
winsound.MessageBeep(winsound.MB_ICONEXCLAMATION)
return True
def _pace(self, t: float) -> None:
"""動画を、選択した再生速度で実時間に合わせて再生する。
解析が追いつかず大きく遅れた場合は、基準時刻を取り直す(遅れを取り戻すための
早送りのような連続処理を防ぐ)。
"""
now = time.perf_counter()
wait = (self.pace_wall + (t - self.pace_t) / SPEEDS[self.speed_i]) - now
if wait > 0:
time.sleep(min(wait, 0.25))
elif wait < -PACE_RESYNC:
self.pace_wall, self.pace_t = now, t
def _update_fps(self) -> None:
self._fps_n += 1
now = time.perf_counter()
if now - self._fps_t >= 0.5:
self.fps = self._fps_n / (now - self._fps_t)
self._fps_t, self._fps_n = now, 0
def _state(self) -> Dict[str, Any]:
calib = None
if not self.an.calibrated:
calib = 0.0 if self.an.calib_t0 is None else clamp(
(self.an.t_now - self.an.calib_t0) / self.an.calib_sec, 0.0, 1.0)
return dict(fps=self.fps, paused=self.paused, rppg=self.cfg.use_rppg,
quality=self.feat["quality"] if self.feat else 0.0,
blink_flash=self.blink_flash, yawn_flash=self.yawn_flash,
mark_flash=self.mark_flash > 0, sound=self.cfg.sound, calib=calib,
alert=self.an.calibrated and self.an.index["drowsy"].level >= 3,
speed=SPEEDS[self.speed_i] if self.is_file else None)
def _compose(self) -> np.ndarray:
"""計測画面に最新の映像パネルを重ねた1枚を作る。"""
np.copyto(self.canvas, self.panel)
view, vmap = letterbox(self.image, VIEW_W, VIEW_H)
self.canvas[VID_Y:VID_Y + VIEW_H, VID_X:VID_X + VIEW_W] = draw_overlay(
view, self.feat, vmap, self._state(), self.text)
return self.canvas
def _save(self) -> Tuple[Dict[str, str], np.ndarray]:
"""レポート・CSV・計測画面・まとめ画面の4ファイルを保存する。"""
paths = record_paths()
dash_img = self._compose().copy()
summary_img = self.dash.summary_sheet(self.an, paths)
self.an.write_records(paths, dash_img, summary_img)
return paths, summary_img
# ------------------------------------------------------------ 操作 ------
def _do(self, action: str, arg: int = 0) -> None:
"""キー操作とマウス操作に共通の処理。"""
if action == "quit":
self.running = False
return
if action == "page":
self.dash.page = arg % N_PAGES
elif action == "next_page":
self.dash.page = (self.dash.page + 1) % N_PAGES
elif action == "tab":
self.dash.tab = arg % N_TABS
elif action == "next_tab":
self.dash.tab = (self.dash.tab + 1) % N_TABS
elif action == "calib":
self.an.recalibrate(self.an.t_now)
self._reset_detectors()
elif action == "pause":
self.paused = not self.paused
self._resync_pace()
elif action == "help":
self.dash.show_help = not self.dash.show_help
elif action == "mirror":
self.cfg.mirror = not self.cfg.mirror
self.extractor.reset()
self.an.mirror_refs()
self.an.add_event(self.an.t_now, "映像の左右反転を切り替えました"
f"({'反転あり' if self.cfg.mirror else '反転なし'})", C_DIM)
elif action == "speed" and self.is_file:
self.speed_i = (self.speed_i + 1) % len(SPEEDS)
self._resync_pace()
elif action == "sound":
self.cfg.sound = not self.cfg.sound
elif action == "mark":
self.an.add_event(self.an.t_now, "目印をつけました(利用者の操作)", C_ACC, mark=True)
self.mark_flash = 40
elif action == "save":
paths, _ = self._save()
self.an.add_event(self.an.t_now,
f"記録を保存: {os.path.basename(paths['txt'])} ほか3件", C_OK)
self.panel = self.dash.build(self.an, self._state())
self.fresh = True
def _handle_key(self, key: int) -> None:
if key == 255:
return
ch = chr(key).lower() if 32 <= key < 127 else ""
if ch and ch in "1234":
self._do("page", int(ch) - 1)
return
action = self.CHAR_ACTIONS.get(ch) or self.CODE_ACTIONS.get(key)
if action:
self._do(action)
def _on_mouse(self, event: int, x: int, y: int, flags: int, param: Any) -> None:
# WINDOW_NORMAL では、OpenCV が画像座標へ換算した値を渡すため再換算は不要
if event != cv2.EVENT_LBUTTONDOWN:
return
for (bx0, by0, bx1, by1), action, arg in self.dash.hits:
if bx0 <= x <= bx1 and by0 <= y <= by1:
self._do(action, arg)
return
# ------------------------------------------------------------ 終了 ------
def _shutdown(self) -> None:
paths, summary_img = self._save()
self.landmarker.close()
self.cap.release()
if cv2.getWindowProperty(WINDOW, cv2.WND_PROP_VISIBLE) >= 1:
cv2.imshow(WINDOW, summary_img)
while cv2.waitKey(80) == -1 and cv2.getWindowProperty(WINDOW, cv2.WND_PROP_VISIBLE) >= 1:
pass
cv2.destroyAllWindows()
print(self.an.report())
for label, key in (("レポート ", "txt"), ("計測値CSV ", "csv"),
("画面の記録", "dash"), ("まとめ画面", "sum")):
print(f"{label}: {paths[key]}")
# ==============================================================================
# 13. エントリポイント
# ==============================================================================
def main() -> None:
# モニタごとの DPI を認識させ、OS による拡大(文字のにじみ)を防ぐ
ctypes.windll.shcore.SetProcessDpiAwareness(2)
config = Launcher().run()
if config is not None:
App(config).run()
if __name__ == "__main__":
main()