サンプルコード ( パノプティックセグメンテーション )

パノプティックセグメンテーションのサンプルコードです

• 最も単純なサンプルコード: L.5- smp_panseg_simple()
• ベンチマークを計測するサンプルコード: L.94: smp_panseg_benchmark()
• 推論結果画像から　FIE の関数を使用して各カテゴリのマスク画像 ( 二値画像 ) を取得するサンプルコード: L.175: smp_panseg_with_fie()

#pragma once
#include "samples.h"
#include "oal_aloc.h"
 
int smp_panseg_simple(const char* model_name, const char* img_name)
{
    INT ret = F_ERR_NONE;
    FHANDLE hsrc = NULL;
    FHANDLE hdst = NULL;
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
    MODEL_BACKEND model_backend;
    INT ch, w, h;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // 画像読込
    ret = fnFIE_load_img_file(img_name, &hsrc, F_COLOR_IMG_TYPE_UC8);
    printf_s("img: %d\r\n", ret);
 
    //------- ここから -------//
 
    // ライセンスチェック
    ret = fnPDL_check_license();
    printf_s("lic : %d\r\n", ret);
 
    // ハンドルの生成
    hmodel = fnPDL_create_handle();
    if (NULL == hmodel) { printf_s("failed to create handle\r\n"); }
    else { printf_s("handle created\r\n"); }
 
    // モデル読込
    ret = fnPDL_load_model(model_name, hmodel);
    printf_s("load: %d\r\n", ret);
 
    // モデルの種別の確認
    ret = fnPDL_get_model_category(hmodel, &model_category);
    printf_s("par : %d  category=%d\r\n", ret, model_category);
    if (SEMANTIC_SEGMENTATION != model_category) { printf_s("unmatch model"); }
 
    // モデルの推論バックエンドの確認
    ret = fnPDL_get_model_backend(hmodel, &model_backend);
    printf_s("ret : %d  backend=%d\r\n", ret, model_backend);
 
    // モデルの期待する画像パラメータの確認
    ret = fnPDL_get_input_image_size(hmodel, &ch, &w, &h);
    printf_s("par : %d  ch=%d  w=%d  h=%d\r\n", ret, ch, w, h);
 
    // パノプティックセグメンテーションに固有の検出パラメータの設定
    ret = fnPDL_set_panoptic_deeplab_infer_params(hmodel,
        1024, // デフォルト値: 物でないクラスとして検出された領域の面積に対する閾値
        0.1,  // デフォルト値: 物体として検出する閾値、感度に相当
        32,   // デフォルト値: 近接する検出に対する非極大抑制のカーネルの大きさ
        0     // デフォルト値: 0 の場合には上限を設けない ( 0 より大きく入力画像サイズ以下のときに有効 )
    );
 
    // セグメンテーション結果画像の確保 ( パノプティックセグメンテーションでは、元画像と同じサイズで画像型は US16、チャネル数は 2 )
    hdst = fnFIE_img_root_alloc(F_IMG_US16, 2, w, h);
    if (NULL == hdst) { printf_s("hdst allocation error"); }
 
    // 推論実行
    ret = fnPDL_predict_segmentation(hmodel, hsrc, hdst);
    printf_s("pred: %d\r\n", ret);
    if (F_ERR_NONE == ret) {
        // 各ピクセルにカテゴリ番号とインスタンス番号が格納されているので、その最大値を取得
        DOUBLE* maxs = (DOUBLE*)fnOAL_calloc(sizeof(DOUBLE), 2);
        DOUBLE* mins = (DOUBLE*)fnOAL_calloc(sizeof(DOUBLE), 2);
        INT max_cate_id = 0;
        INT instance_num = 0;
 
        // 画像全体のリージョンに対して fnFIE_img_maxpixel() を使用することも可  
        ret = fnFIE_img_minmaxdens(hdst, mins, maxs);
 
        // カテゴリ番号の最大値
        max_cate_id = (INT)maxs[0];
        // 最大値が 0 となるのは、全てのピクセルが背景と判定されたとき
        if (0 == max_cate_id) { printf_s("all pixels are background"); }
        // 1 以上となるのは、いずれかのカテゴリと判定されたピクセルが存在するとき ( 元が US16 なので負の値になることは無い )
        else { printf_s("there are some masks, largest category id = %d\r\n", max_cate_id); }
        if (NULL != maxs) { fnOAL_free(maxs); }
        if (NULL != mins) { fnOAL_free(mins); }
 
        // インスタンス番号の最大値 = 見つかったマスクの個数
        instance_num = (INT)maxs[1];
        printf_s("there are %d masks", instance_num);
    }
 
    // ハンドルの破棄
    fnPDL_dispose(hmodel);
 
    //------- ここまで -------//
 
    // 終了処理
    if (NULL != hsrc) { fnFIE_free_object(hsrc); }
    if (NULL != hdst) { fnFIE_free_object(hdst); }
    fnFIE_teardown();
 
    return ret;
}
 
int smp_panseg_benchmark(const char* model_name, const char* img_name, const int bench_iter)
{
    // benchmark 用
    std::chrono::system_clock::time_point start, end;
 
    INT ret = F_ERR_NONE;
    FHANDLE hsrc = NULL;
    FHANDLE hdst = NULL;
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // 画像読込
    ret = fnFIE_load_img_file(img_name, &hsrc, F_COLOR_IMG_TYPE_UC8);
    printf_s("img: %d\r\n", ret);
    if (F_ERR_NONE != ret) { goto finally; }
 
    // ライセンスチェック
    ret = fnPDL_check_license();
    printf_s("lic : %d\r\n", ret);
 
    // ハンドルの生成
    hmodel = fnPDL_create_handle();
    if (NULL == hmodel) { printf_s("failed to create handle\r\n"); }
    else { printf_s("handle created\r\n"); }
 
    // モデル読込
    ret = fnPDL_load_model(model_name, hmodel);
    printf_s("load: %d\r\n", ret);
 
    // モデルの種別の確認
    ret = fnPDL_get_model_category(hmodel, &model_category);
    printf_s("par : %d  category=%d\r\n", ret, model_category);
    if (SEMANTIC_SEGMENTATION != model_category) { printf_s("unmatch model"); }
 
    // セグメンテーション結果画像の確保 ( パノプティックセグメンテーションでは、元画像と同じサイズで画像型は US16、チャネル数は 2 )
    hdst = fnFIE_img_root_alloc(F_IMG_US16, 2, fnFIE_img_get_width(hsrc), fnFIE_img_get_height(hsrc));
    if (NULL == hdst) { printf_s("hdst allocation error"); }
 
    printf_s("--- start ---\r\n");
    printf_s("ret, elapsed[msec], scores\r\n");
    // 本体ループ
    for (int i = 0; i < bench_iter; i++) {
        double elapsed;
 
        // 開始時刻
        start = std::chrono::system_clock::now();
 
        // 推論実行
        ret = fnPDL_predict_segmentation(hmodel, hsrc, hdst);
 
        // 完了時刻
        end = std::chrono::system_clock::now();
 
        if (F_ERR_NONE != ret) {
            printf_s("pred. err: %d\r\n", ret);
            goto finally;
        }
 
        // 推論時間 [msec]
        elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / (double)1000;
 
        // コンソールに出力
        printf_s("%04d, %.3e\r\n", i, elapsed);
    }
    printf_s("--- finish ---\r\n");
 
    // ハンドルの破棄
    fnPDL_dispose(hmodel);
 
    finally:
    // 終了処理
    if (NULL != hsrc) { fnFIE_free_object(hsrc); }
    if (NULL != hdst) { fnFIE_free_object(hdst); }
    fnFIE_teardown();
 
    return ret;
}
 
int smp_panseg_with_fie(const char* model_name, const char* img_name, const INT category_num)
{
    INT ret = F_ERR_NONE;
    FHANDLE hsrc = NULL;
    FHANDLE hdst = NULL;
    FHANDLE hdst_cate = NULL;
    FHANDLE hdst_inst = NULL;
    FHANDLE hdst_cate_tmp = NULL;
    FHANDLE hdst_inst_tmp = NULL;
    INT instance_num = 0;
    FHANDLE hmask = NULL;
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
 
    INT ch, w, h, type;
    INT_PTR step;
 
    DOUBLE* maxs = NULL;
    DOUBLE* mins = NULL;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // 画像読込
    ret = fnFIE_load_img_file(img_name, &hsrc, F_COLOR_IMG_TYPE_UC8);
    printf_s("img: %d\r\n", ret);
 
    //------- ここから -------//
 
    // ライセンスチェック
    ret = fnPDL_check_license();
    printf_s("lic : %d\r\n", ret);
 
    // ハンドルの生成
    hmodel = fnPDL_create_handle();
    if (NULL == hmodel) { printf_s("failed to create handle\r\n"); goto finally; }
    else { printf_s("handle created\r\n"); }
 
    // モデル読込
    ret = fnPDL_load_model(model_name, hmodel);
    printf_s("load: %d\r\n", ret);
    if (F_ERR_NONE != ret) { goto finally; }
 
    // モデルの種別の確認
    ret = fnPDL_get_model_category(hmodel, &model_category);
    printf_s("par : %d  category=%d\r\n", ret, model_category);
    if (SEMANTIC_SEGMENTATION != model_category) { printf_s("unmatch model"); goto finally; }
 
    // セグメンテーション結果画像の確保 ( パノプティックセグメンテーションでは、元画像と同じサイズで画像型は US16、チャネル数は 2 )
    hdst = fnFIE_img_root_alloc(F_IMG_US16, 2, w, h);
    if (NULL == hdst) { printf_s("hdst allocation error"); goto finally; }
 
    // 推論実行
    ret = fnPDL_predict_segmentation(hmodel, hsrc, hdst);
    printf_s("pred(original): %d\r\n", ret);
    if (F_ERR_NONE != ret) { goto finally; }
 
    // カテゴリ番号の格納された画像 ( 0ch ) とインスタンス番号の格納された画像 ( 1ch ) の確保
    hdst_cate = fnFIE_img_child_alloc_single_ch(hdst, 0, 0, 0, w, h);
    hdst_inst = fnFIE_img_child_alloc_single_ch(hdst, 1, 0, 0, w, h);
 
    // 検出インスタンス数の取得
    {
        maxs = (DOUBLE*)fnOAL_calloc(sizeof(DOUBLE), 1);
        mins = (DOUBLE*)fnOAL_calloc(sizeof(DOUBLE), 1);
        ret = fnFIE_img_minmaxdens(hdst_inst, mins, maxs);
        if (F_ERR_NONE != ret) { goto finally; }
        instance_num = (INT)maxs[0];
    }
 
    // 各カテゴリのマスク画像の確保 ( 元画像・結果画像と同じサイズで画像型は BIN、チャネル数は 1 )
    hmask = fnFIE_img_root_alloc(F_IMG_BIN, 1, w, h);
    if (NULL == hdst) { printf_s("hmask allocation error"); goto finally; }
 
    // カテゴリ基準でマスクを取得する場合
    {
        hdst_cate_tmp = fnFIE_img_root_alloc(F_IMG_BIN, 1, w, h);
        if (NULL == hdst_cate_tmp) { printf_s("hcate_tmp allocation error"); goto finally; }
        hdst_inst_tmp = fnFIE_img_root_alloc(F_IMG_US16, 1, w, h);
        if (NULL == hdst_inst_tmp) { printf_s("hinst_tmp allocation error"); goto finally; }
 
        // 全てのカテゴリを走査
        for (int i_cate = 1; i_cate <= category_num; i_cate++) {
            // カテゴリ番号に一致するピクセルを取得
            ret = fnFIE_band_threshold(hdst_cate, hdst_cate_tmp, (DOUBLE)i_cate, (DOUBLE)i_cate);
            if (F_ERR_NONE != ret) { continue; }
 
            // 0 クリアして、そのカテゴリ領域のインスタンス画像をマスク転送
            ret = fnFIE_img_clear(hdst_inst_tmp, 0);
            if (F_ERR_NONE != ret) { continue; }
            ret = fnFIE_img_mask(hdst_inst, hdst_cate_tmp, hdst_inst_tmp);
            if (F_ERR_NONE != ret) { continue; }
 
            // ここでは単純にインスタンス数を全て走査
            for (int i_inst = 0; i_inst <= instance_num; i_inst++) {
                ret = fnFIE_band_threshold(hdst_inst_tmp, hmask, (DOUBLE)i_inst, (DOUBLE)i_inst);
                if (F_ERR_NONE != ret) { continue; }
 
                // hmask の全面 ( 最大値 ) が 0 であれば、そのインスタンスはそのカテゴリではないのでスキップ ( リージョンに変換して面積で判定しても可 )
                ret = fnFIE_img_minmaxdens(hmask, mins, maxs);
                if (F_ERR_NONE != ret) { goto finally; }
                if (0 == maxs[0]) { continue; }
 
                // hmask に対する任意の処理 ( ブロブ特徴量の取得やリージョン特徴量の取得など )
                //
            }
        }
    }
 
    // インスタンス基準でマスクを取得する場合
    {
        hdst_cate_tmp = fnFIE_img_root_alloc(F_IMG_US16, 1, w, h);
        if (NULL == hdst_cate_tmp) { printf_s("hcate_tmp allocation error"); goto finally; }
        // ここではインスタンス番号の領域で直接インスタンスの領域を取得できるの確保不要
        //hinst_tmp = fnFIE_img_root_alloc(F_IMG_BIN, 1, w, h);
        //if (NULL == hinst_tmp) { printf_s("hinst_tmp allocation error"); goto finally; }
 
        // 全てのインスタンスを走査
        for (int i_inst = 0; i_inst <= instance_num; i_inst++) {
            // インスタンス番号に一致するピクセルを取得
            ret = fnFIE_band_threshold(hdst_inst, hmask, (DOUBLE)i_inst, (DOUBLE)i_inst);
            if (F_ERR_NONE != ret) { continue; }
 
            // 0 クリアして、そのインスタンス領域のカテゴリ画像をマスク転送 ( 先にインスタンス画像をリージョンに変換してそのリージョン内の濃度値を取得しても可 )
            ret = fnFIE_img_clear(hdst_cate_tmp, 0);
            if (F_ERR_NONE != ret) { continue; }
            ret = fnFIE_img_mask(hdst_cate, hmask, hdst_cate_tmp);
            if (F_ERR_NONE != ret) { continue; }
 
            // maxs[0] でカテゴリ番号を取得
            ret = fnFIE_img_minmaxdens(hdst_cate_tmp, mins, maxs);
            if (F_ERR_NONE != ret) { goto finally; }
            if (0 == maxs[0]) { continue; }// カテゴリ番号が 0 のときは背景
            if (category_num < maxs[0]) { continue; }// カテゴリ番号が与えられたカテゴリ数よりも大きいのは不合理
 
            // hmask に対する任意の処理 ( ブロブ特徴量の取得やリージョン特徴量の取得など )
            //
        }
    }
 
    finally:
    // ハンドルの破棄
    fnPDL_dispose(hmodel);
 
    //------- ここまで -------//
 
    if (NULL != hsrc) { fnFIE_free_object(hsrc); }
    if (NULL != hdst) { fnFIE_free_object(hdst); }
    if (NULL != hdst_cate) { fnFIE_free_object(hdst_cate); }
    if (NULL != hdst_inst) { fnFIE_free_object(hdst_inst); }
    if (NULL != hdst_cate_tmp) { fnFIE_free_object(hdst_cate); }
    if (NULL != hdst_inst_tmp) { fnFIE_free_object(hdst_inst); }
    if (NULL != hmask) { fnFIE_free_object(hmask); }
    if (NULL != maxs) { fnOAL_free(maxs); }
    if (NULL != mins) { fnOAL_free(mins); }
 
    // 終了処理
    fnFIE_teardown();
 
    return ret;
}