OpenVINO によるモノデプス推定#

import platform 

%pip install -q "openvino>=2023.1.0" 
%pip install -q opencv-python requests tqdm 

if platform.system() != "Windows":
     %pip install -q "matplotlib>=3.4" 
else:
     %pip install -q "matplotlib>=3.4,<3.7" 

# `notebook_utils` モジュールを取得 
import requests 

r = requests.get( 
    url="https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/notebook_utils.py", 
) 

open("notebook_utils.py", "w").write(r.text)

import time 
from pathlib import Path 

import cv2 
import matplotlib.cm 
import matplotlib.pyplot as plt 
import numpy as np 
from IPython.display import ( 
    HTML, 
    FileLink, 
    Pretty, 
    ProgressBar, 
    Video, 
    clear_output, 
    display, 
) 
import openvino as ov 

from notebook_utils import download_file, load_image

model_folder = Path("model") 

ir_model_url = "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/models/depth-estimation-midas/FP32/" 
ir_model_name_xml = "MiDaS_small.xml" 
ir_model_name_bin = "MiDaS_small.bin" 

download_file(ir_model_url + ir_model_name_xml, filename=ir_model_name_xml, directory=model_folder) 
download_file(ir_model_url + ir_model_name_bin, filename=ir_model_name_bin, directory=model_folder) 

model_xml_path = model_folder / ir_model_name_xml

IMAGE_FILE = "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/image/coco_bike.jpg" 
image = load_image(path=IMAGE_FILE) 

# ネットワークの入力形状に合わせてサイズを変更 
resized_image = cv2.resize(src=image, dsize=(network_image_height, network_image_width)) 

# 画像をネットワーク入力形状 NCHW に合わせて再形成 
input_image = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0)

result = compiled_model([input_image])[output_key] 

# 視差マップのネットワーク結果を、 
# 距離を色で表示する画像に変換 
result_image = convert_result_to_image(result=result) 

# 元の画像の形状にサイズを戻す。`cv2.resize` 関数は(幅、高さ) の形状を想定しており、 
# [::-1] はこれに一致するように (高さ、幅) の形状を反転 
result_image = cv2.resize(result_image, image.shape[:2][::-1])

fig, ax = plt.subplots(1, 2, figsize=(20, 15)) 
ax[0].imshow(to_rgb(image)) 
ax[1].imshow(result_image);

# ビデオソース: https://www.youtube.com/watch?v=fu1xcQdJRws (パブリックドメイン) 
VIDEO_FILE = 
"https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/video/Coco%20Walking%20in%20Berkeley.mp4" 
# 処理する入力ビデオの秒数ビデオ全体を処理するには、 
# `NUM_SECONDS` を 0 に設定
NUM_SECONDS = 4 
# 入力ビデオのすべてのフレームを処理するには、`ADVANCE_FRAMES` を 1 に設定 
# 1 フレームごとに処理するには、`ADVANCE_FRAMES` を 2 に設定。これにより、 
# ビデオの処理にかかる時間が短縮されます。
ADVANCE_FRAMES = 2 
# 結果のビデオのサイズを縮小するには、`SCALE_OUTPUT` を設定 
# `SCALE_OUTPUT` が 0.5 の場合、結果ビデオの幅と高さは 
# 入力ビデオの幅と高さの半分になります。
SCALE_OUTPUT = 0.5 
# ビデオのエンコードに使用する形式。'vp09` は低速ですが、 
# ほとんどのシステムで動作します
# FFMPEG がインストールされている場合は、`THEO` エンコードを試してください。
# FOURCC = cv2.VideoWriter_fourcc(*"THEO") 
FOURCC = cv2.VideoWriter_fourcc(*"vp09") 

# 入力ビデオと結果ビデオの Path オブジェクトを作成 
output_directory = Path("output") 
output_directory.mkdir(exist_ok=True) 
result_video_path = output_directory / f"{Path(VIDEO_FILE).stem}_monodepth.mp4"

cap = cv2.VideoCapture(str(VIDEO_FILE)) 
ret, image = cap.read() 
if not ret: 
    raise ValueError(f"The video at {VIDEO_FILE} cannot be read.") 
input_fps = cap.get(cv2.CAP_PROP_FPS) 
input_video_frame_height, input_video_frame_width = image.shape[:2] 

target_fps = input_fps / ADVANCE_FRAMES 
target_frame_height = int(input_video_frame_height * SCALE_OUTPUT) 
target_frame_width = int(input_video_frame_width * SCALE_OUTPUT) 

cap.release() 
print(f"The input video has a frame width of {input_video_frame_width}, " f"frame height of {input_video_frame_height} and runs at {input_fps:.2f} fps") 
print( 
    "The monodepth video will be scaled with a factor " 
    f"{SCALE_OUTPUT}, have width {target_frame_width}, " 
    f" height {target_frame_height}, and run at {target_fps:.2f} fps" 
)

# 変数を初期化 
input_video_frame_nr = 0 
start_time = time.perf_counter() 
total_inference_duration = 0 

# 入力ビデオを開く 
cap = cv2.VideoCapture(str(VIDEO_FILE)) 

# 結果ビデオを作成 
out_video = cv2.VideoWriter( 
    str(result_video_path), 
    FOURCC, 
    target_fps, 
    (target_frame_width * 2, target_frame_height), 
) 

num_frames = int(NUM_SECONDS * input_fps) 
total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT) if num_frames == 0 else num_frames 
progress_bar = ProgressBar(total=total_frames) 
progress_bar.display() 

try: 
    while cap.isOpened(): 
        ret, image = cap.read() 
        if not ret: 
            cap.release() 
            break 

        if input_video_frame_nr >= total_frames: 
            break 

        # 2 フレームごとにのみ処理 
        # 推論のためのフレームを準備
        # ネットワークの入力形状に合わせてサイズを変更 
        resized_image = cv2.resize(src=image, dsize=(network_image_height, network_image_width)) 
        # 画像をネットワーク入力形状 NCHW に合わせて再形成 
        input_image = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0) 

        # 推論を実行 
        inference_start_time = time.perf_counter() 
        result = compiled_model([input_image])[output_key] 
        inference_stop_time = time.perf_counter() 
        inference_duration = inference_stop_time - inference_start_time 
        total_inference_duration += inference_duration 

        if input_video_frame_nr % (10 * ADVANCE_FRAMES) == 0: 
            clear_output(wait=True) 
            progress_bar.display() 
            # input_video_frame_nr // ADVANCE_FRAMES は、 
            # ネットワークによって処理されたフレームの数を示します。 
            display( 
                Pretty( 
                    f"Processed frame {input_video_frame_nr // ADVANCE_FRAMES}" 
                    f"/{total_frames // ADVANCE_FRAMES}." 
                    f"Inference time per frame: {inference_duration:.2f} seconds " 
                    f"({1/inference_duration:.2f} FPS)" 
                    ) 
            ) 
    # ネットワーク結果を RGB 画像に変換 
    result_frame = to_rgb(convert_result_to_image(result)) 
    # 画像と結果をターゲットのフレーム形状に合わせてサイズを変更 
    result_frame = cv2.resize(result_frame, (target_frame_width, target_frame_height)) 
    image = cv2.resize(image, (target_frame_width, target_frame_height)) 
    # 画像と結果を並べて表示 
    stacked_frame = np.hstack((image, result_frame)) 
    # ビデオにフレームを保存 
    out_video.write(stacked_frame) 

    input_video_frame_nr = input_video_frame_nr + ADVANCE_FRAMES 
    cap.set(1, input_video_frame_nr) 

    progress_bar.progress = input_video_frame_nr 
    progress_bar.update() 

except KeyboardInterrupt: 
    print("Processing interrupted.") 
finally: 
    clear_output() 
    processed_frames = num_frames // ADVANCE_FRAMES 
    out_video.release() 
    cap.release() 
    end_time = time.perf_counter() 
    duration = end_time - start_time 

    print( 
        f"Processed {processed_frames} frames in {duration:.2f} seconds."
        f"Total FPS (including video processing): {processed_frames/duration:.2f}." 
        f"Inference FPS: {processed_frames/total_inference_duration:.2f} " 
    ) 
    print(f"Monodepth Video saved to '{str(result_video_path)}'.")

video = Video(result_video_path, width=800, embed=True) 
if not result_video_path.exists(): 
    plt.imshow(stacked_frame) 
    raise ValueError("OpenCV was unable to write the video file.Showing one video frame.") 
else: 
    print(f"Showing monodepth video saved at\n{result_video_path.resolve()}") 
    print("If you cannot see the video in your browser, please click on the " "following link to download the video ") 
    video_link = FileLink(result_video_path) 
    video_link.html_link_str = "<a href='%s' download>%s</a>" 
    display(HTML(video_link._repr_html_())) 
    display(video)