WIL を併用するサンプルコード

WIL を併用するサンプルコードです。
ここでは、任意のフィルタ処理 ( この例では単純な平均化フィルタ ) を前処理として実施しています。

• C#
• VB

---

C# 版

• 画像分類の場合: L.61- UseWithWIL()
• アノマリー検出の場合: L.61- UseWithWIL()
• 多視点画像分類の場合: L.148- UseWithWILMVCNN()
• 多視点アノマリー検出の場合: L.148- UseWithWILMVCNN()
• セマンティックセグメンテーションの場合: L.214- UseWithWILSegmentation()
• パノプティックセグメンテーションの場合: L.214- UseWithWILSegmentation()
• 物体検出の場合: L.384- UseWithWILObjectDetection()
• マルチラベル画像分類の場合: L.61- UseWithWIL()

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FVIL;
using FVIL.Data;
using FVIL.PDL;
 
namespace SamplesCS
{
    partial class Program
    {
        static void _predict(Model model, CFviImage targetImage)
        {
            switch (model.ModelCategory)
            {
                case ModelCategory.Classification:// 画像分類
                    {
                        // 推論実行
                        var scores = model.PredictClassification(targetImage);
 
                        // スコアをコンソール出力
                        for (var i_score = 0; i_score < scores.Length; i_score++)
                        {
                            Console.WriteLine($"label{i_score}: {scores[i_score]}");
                        }
                    }
                    break;
                case ModelCategory.AnomalyDetection:// アノマリー検出
                    {
                        // 閾値を任意に設定して推論実行 ( double から float キャストに注意 )
                        var threshold = 10.0;
                        var tuple = model.PredictAnomaly(targetImage, (float)threshold);
 
                        // コンソール出力
                        var str_is_anomaly = tuple.Item1 ? "anomaly" : "normal";
                        Console.WriteLine($"{str_is_anomaly}, max_anomaly={tuple.Item2}");
                    }
                    break;
                case ModelCategory.MultiLabelClassification:// マルチラベル画像分類
                    {
                        // 推論実行
                        var scores = model.PredictMultiLabelClassification(targetImage);
 
                        // スコアをコンソール出力
                        for (var i_score = 0; i_score < scores.Length; i_score++)
                        {
                            Console.WriteLine($"label{i_score}: {scores[i_score]}");
                        }
                    }
                    break;
                case ModelCategory.MultiViewCNN:
                case ModelCategory.MultiViewAD:
                case ModelCategory.SemanticSegmentation:
                case ModelCategory.PanopticSegmentation:
                case ModelCategory.Unknown:
                default: throw new NotImplementedException($"unknwon model-category={model.ModelCategory}");
            }
        }
        static void UseWithWIL(String modelPath, String imagePath)
        {
            try
            {
                var has_license = Model.CheckLicense();
                if (false == has_license) { throw new Exception("no license"); }
 
                // モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Model model = new Model(modelPath);
 
                // 推論対象画像の読込
                CFviImage image = new CFviImage(imagePath);
 
                // 推論対象画像の有効性確認
                var is_valid_img = model.IsValidImage(image);
                if (false == is_valid_img) { throw new Exception("invalid image"); }
 
                // 元画像での推論
                Console.WriteLine("original image");
                _predict(model, image);
 
                // 任意のフィルタ処理 ( ここでは例として単純な average フィルタ )
                var filtered_image = new CFviImage(image, false);
                var parser = new FVIL.Filter.CFviAverageFilter();
                parser.SrcImages[0] = image;
                parser.DstImages[0] = filtered_image;
                if (!parser.IsValid())
                {
                    parser.Validate();
                }
                parser.Execute();
 
                // 処理画像での推論
                Console.WriteLine("filtered image");
                _predict(model, filtered_image);
            }
            catch (CFviException ex)
            {
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }
 
        static void _predictMultiView(Model model, IEnumerable<CFviImage> targetImages)
        {
            // モデル種別のエラーチェック
            switch (model.ModelCategory)
            {
                case ModelCategory.MultiViewCNN:
                    {
                        // 推論実行
                        var scores = model.PredictMultiViewCNN(targetImages);
 
                        // スコアをコンソール出力
                        for (var i_score = 0; i_score < scores.Length; i_score++)
                        {
                            Console.WriteLine($"label{i_score}: {scores[i_score]}");
                        }
                    }
                    break;
                case ModelCategory.MultiViewAD:
                    {
                        {
                            // 閾値を任意に設定して推論実行 ( double から float キャストに注意 )
                            var threshold = 10.0;
                            var tuple = model.PredictMultiViewAD(targetImages, (float)threshold);
 
                            // コンソール出力
                            var str_is_anomaly = tuple.Item1 ? "anomaly" : "normal";
                            Console.WriteLine($"{str_is_anomaly}, max_anomaly={tuple.Item2}");
                        }
                    }
                    break;
                case ModelCategory.Unknown:
                case ModelCategory.Classification:
                case ModelCategory.AnomalyDetection:
                case ModelCategory.SemanticSegmentation:
                case ModelCategory.PanopticSegmentation:
                default: throw new NotImplementedException($"unmatch model-category={model.ModelCategory}");
            }
 
        }
        static void UseWithWILMultiImage(String modelPath, String imageFolder)
        {
            try
            {
                var has_license = Model.CheckLicense();
                if (false == has_license) { throw new Exception("no license"); }
 
                // モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Model model = new Model(modelPath);
 
                // 推論対象画像の読込と有効性の確認
                List<CFviImage> original_images = new List<CFviImage>();
                for (var i_img = 0; i_img < model.NumViews; i_img++)
                {
                    // imageFolder フォルダ内に、0-index の通し番号の画像が保存されていることを想定
                    var img_path = System.IO.Path.Combine(imageFolder, String.Format("{0}.bmp", i_img));
                    var image = new CFviImage(img_path);
 
                    // 推論対象画像の有効性確認
                    var is_valid_img = model.IsValidImage(image);
                    if (false == is_valid_img) { throw new Exception("invalid image"); }
 
                    // 推論対象画像のリストに追加
                    original_images.Add(image);
                }
 
                // 元画像での推論
                Console.WriteLine("original image");
                _predictMultiView(model, original_images);
 
                // 任意のフィルタ処理 ( ここでは例として単純な average フィルタ )
                List<CFviImage> filtered_images = new List<CFviImage>();
                using (var parser = new FVIL.Filter.CFviAverageFilter())
                {
                    foreach (var src_image in original_images)
                    {
                        var dst_image = new CFviImage(src_image.HorzSize, src_image.VertSize, src_image.ImageType, src_image.Channel);
 
                        parser.SrcImages[0] = src_image;
                        parser.DstImages[0] = dst_image;
                        if (!parser.IsValid())
                        {
                            parser.Validate();
                        }
                        parser.Execute();
 
                        filtered_images.Add(dst_image);
                    }
                }
 
                // 処理画像での推論
                Console.WriteLine("filtered image");
                _predictMultiView(model, filtered_images);
            }
            catch (CFviException ex)
            {
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }
 
        static void UseWithWILSegmentation(String modelPath, String imagePath, Double blobAreaMinThreshold, Double blobAreaMaxThreshold)
        {
            try
            {
                var has_license = Model.CheckLicense();
                if (false == has_license) { throw new Exception("no license"); }
 
                // モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Model model = new Model(modelPath);
 
                // 推論対象画像の読込
                CFviImage image = new CFviImage(imagePath);
 
                // 推論対象画像の有効性確認
                var is_valid_img = model.IsValidImage(image);
                if (false == is_valid_img) { throw new Exception("invalid image"); }
 
 
                switch (model.ModelCategory)
                {
                    case ModelCategory.SemanticSegmentation:// セマンティックセグメンテーション
                        {
                            // 推論実行
                            var segm_result_image = model.PredictSemanticSegmentation(image);
 
                            // 濃度値の最大が領域を検出できたカテゴリたちの中での最大の番号に相当
                            var max_posi = segm_result_image.FindMaxValue(0, 0);
                            var max_value = segm_result_image.GetPixelI32(0, (Int32)max_posi.X, (Int32)max_posi.Y);
                            if (0 == max_value)
                            {// 0 が最大値ということは 1 以上のピクセルが無い。つまり画像の全てが背景と判定されたとき
                                Console.WriteLine("all pixels are background");
                            }
 
                            // カテゴリの個数: 既知であればここで取得する必要は無い
                            var n_category = model.GetLabelList().Count();
 
                            // 各カテゴリ ( ラベル ) の情報を取得: 0 番は背景に対応し、カテゴリ番号は 1-index であることに注意
                            for (var category_id = 1; category_id <= n_category; category_id++)
                            {
                                // カテゴリ番号に一致するピクセルのみを 1 に、その他を 0 にすることで、そのカテゴリとして検出された領域の二値画像を取得
                                // ※ PredictSemanticSegmentation(CFviImage targetImage, Dictionary<UInt32, CFviImage> categoryMaskImages) にて categoryMaskImages で取得できる二値画像に相当
                                var bin_mask = new CFviImage(segm_result_image.HorzSize, segm_result_image.VertSize, ImageType.BIN, 1, 1);
                                bin_mask.Window = segm_result_image.Window;
                                var ret = fvalgcli.api.fnFIE_band_threshold(segm_result_image.GetFIEChild(), bin_mask.GetFIEChild(), category_id, category_id);
                                if ((Int32)fvalgcli.f_err.F_ERR_NONE != ret) { throw new fvalgcli.FvException(ret); }
 
                                // 検出した領域の二値画像に対してブローブ解析を実行
                                var blob_result = new FVIL.Blob.CFviBlobResult();
                                var blob_param = new FVIL.Blob.CFviBlobParam();
                                blob_param.ColorMode = FVIL.Blob.ObjectColor.WhiteFG_BlackBG;
                                blob_param.Neighborhood = FVIL.Blob.Neighborhood.Eight;
                                var blob_parser = new FVIL.Blob.CFviBlob(bin_mask, blob_result, blob_param);
                                if (!blob_parser.IsValid()) { blob_parser.Validate(); }
                                blob_parser.Execute();
 
                                // ブローブ解析の結果に対して、さらにフィルタリング ( ここでは面積 )
                                var filters = new List<FVIL.Blob.CFviBlobFilterRange>();
                                filters.Add(new FVIL.Blob.CFviBlobFilterRange(FVIL.Blob.FeatureType.AREA, blobAreaMinThreshold, blobAreaMaxThreshold));
                                var blob_list = blob_result.GetBlobList(filters);
                                Console.WriteLine($"category_id={category_id}: blob count={blob_list.Count}");
                                foreach(var kv in blob_list)
                                {
                                    var blob_data = new FVIL.Blob.CFviBlobData(kv);
                                    // 以下、ブローブ特徴量に基づく解析も可能
                                }
 
                                // 検出した領域の二値画像をリージョンに変換
                                var region_mask = new CFviRegion(bin_mask);
                                // リージョン特徴量に基づく解析や、画像に対するリージョン内の特徴量の取得が可能
                                //var mean = FVIL.Region.Measure.MeanPixel(image, region_mask);// 例: 元画像のリージョン内の平均濃度値の取得
                            }
                        }
                        break;
                    case ModelCategory.PanopticSegmentation:
                        {
                            // 推論実行
                            var segm_result_image = model.PredictPanopticSegmentation(image);
 
                            // カテゴリ番号の格納された画像とインスタンス番号の格納された画像に分離
                            var category_map = new CFviImage(fvalgcli.api.fnFIE_img_child_alloc_single_ch(segm_result_image.GetFIERoot(), 0, 0, 0, segm_result_image.HorzSize, segm_result_image.VertSize), true);
                            var instance_map = new CFviImage(fvalgcli.api.fnFIE_img_child_alloc_single_ch(segm_result_image.GetFIERoot(), 1, 0, 0, segm_result_image.HorzSize, segm_result_image.VertSize), true);
                            category_map.Window = segm_result_image.Window;
                            instance_map.Window = segm_result_image.Window;
 
                            // 濃度値の最大が検出した領域の個数に相当
                            var max_posi = instance_map.FindMaxValue(0, 0);
                            var max_value = instance_map.GetPixelI32(0, (Int32)max_posi.X, (Int32)max_posi.Y);
                            if (0 == max_value)
                            {// 0 が最大値ということは 1 以上のピクセルが無い。つまり画像の全てが背景と判定されたとき
                                Console.WriteLine("all pixels are background");
                            }
 
                            // 各検出領域の取得と、その領域に対する画像処理
                            for (var instance_id = 1; instance_id <= max_value; instance_id++)
                            {
                                // 検出した領域の通し番号に一致するピクセルのみを 1 に、その他を 0 にすることで、その領域の二値画像を取得
                                var bin_mask = new CFviImage(instance_map.HorzSize, instance_map.VertSize, ImageType.BIN, 1, 1);
                                bin_mask.Window = instance_map.Window;
                                var ret = fvalgcli.api.fnFIE_band_threshold(instance_map.GetFIEChild(), bin_mask.GetFIEChild(), instance_id, instance_id);
                                if ((Int32)fvalgcli.f_err.F_ERR_NONE != ret) { throw new fvalgcli.FvException(ret); }
 
                                // 検出した領域の二値画像に対してブローブ解析を実行 ( 物体毎に分離できているはずなので、各インスタンスの領域がそれ以上に分割されることはほとんど無いはず )
                                var blob_result = new FVIL.Blob.CFviBlobResult();
                                var blob_param = new FVIL.Blob.CFviBlobParam();
                                blob_param.ColorMode = FVIL.Blob.ObjectColor.WhiteFG_BlackBG;
                                blob_param.Neighborhood = FVIL.Blob.Neighborhood.Eight;
                                var blob_parser = new FVIL.Blob.CFviBlob(bin_mask, blob_result, blob_param);
                                if (!blob_parser.IsValid()) { blob_parser.Validate(); }
                                blob_parser.Execute();
 
                                // ブローブ解析の結果に対して、さらにフィルタリング ( ここでは面積 )
                                var filters = new List<FVIL.Blob.CFviBlobFilterRange>();
                                filters.Add(new FVIL.Blob.CFviBlobFilterRange(FVIL.Blob.FeatureType.AREA, blobAreaMinThreshold, blobAreaMaxThreshold));
                                var blob_list = blob_result.GetBlobList(filters);
                                Console.WriteLine($"instance_id={instance_id}: blob count={blob_list.Count}");
                                foreach (var kv in blob_list)
                                {
                                    var blob_data = new FVIL.Blob.CFviBlobData(kv);
 
                                    var region = blob_data.GetRegion();
                                    var category_id = (UInt32)FVIL.Region.Measure.MaxPixel(category_map, region, OriginMode.Window);// max=min のはずで、領域をすべて見なくても 1 ピクセルを確認するのみでも良い
 
                                    Console.WriteLine($"instance_id={instance_id}: category_id={category_id}, blob no={blob_data.BlobNo}");
 
                                    // 以下、ブローブ特徴量に基づく解析も可能
                                }
 
                                // 検出した領域の二値画像を直接リージョンに変換
                                var region_mask = new CFviRegion(bin_mask);
                                // リージョン特徴量に基づく解析や、画像に対するリージョン内の特徴量の取得が可能
                                //var mean = FVIL.Region.Measure.MeanPixel(image, region_mask);// 例: 元画像のリージョン内の平均濃度値の取得
                            }
                        }
                        break;
                    case ModelCategory.Classification:
                    case ModelCategory.AnomalyDetection:
                    case ModelCategory.MultiViewCNN:
                    case ModelCategory.MultiViewAD:
                    case ModelCategory.Unknown:
                    default: throw new NotImplementedException($"unknwon model-category={model.ModelCategory}");
                }
            }
            catch (CFviException ex)
            {
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }
 
        static void _predictObjectDetection(Model model, CFviImage targetImage)
        {
            switch (model.ModelCategory)
            {
                case ModelCategory.ObjectDetection:// 物体検出
                    {
                        // 推論実行
                        var detections = model.PredictObjectDetection(targetImage);
 
                        // 検出数をコンソール出力
                        Console.WriteLine($"number of detections: {detections.Count()}");
                    }
                    break;
                default: throw new NotImplementedException($"unknwon model-category={model.ModelCategory}");
            }
        }
        static void UseWithWILObjectDetection(String modelPath, String imagePath)
        {
            try
            {
                var has_license = Model.CheckLicense();
                if (false == has_license) { throw new Exception("no license"); }
 
                // モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Model model = new Model(modelPath);
 
                // 推論対象画像の読込
                CFviImage image = new CFviImage(imagePath);
 
                // 推論対象画像の有効性確認
                var is_valid_img = model.IsValidImage(image);
                if (false == is_valid_img) { throw new Exception("invalid image"); }
 
                // 元画像での推論
                Console.WriteLine("original image");
                _predictObjectDetection(model, image);
 
                // 任意のフィルタ処理 ( ここでは例として単純な average フィルタ )
                var filtered_image = new CFviImage(image, false);
                var parser = new FVIL.Filter.CFviAverageFilter();
                parser.SrcImages[0] = image;
                parser.DstImages[0] = filtered_image;
                if (!parser.IsValid())
                {
                    parser.Validate();
                }
                parser.Execute();
 
                // 処理画像での推論
                Console.WriteLine("filtered image");
                _predictObjectDetection(model, filtered_image);
            }
            catch (CFviException ex)
            {
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Message={ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }
 
    }
}

VB 版

• 画像分類の場合: L.42- UseWithWIL()
• アノマリー検出の場合: L.42- UseWithWIL()
• 多視点画像分類の場合: L.114- UseWithWILMVCNN()
• 多視点アノマリー検出の場合: L.114- UseWithWILMVCNN()
• セマンティックセグメンテーションの場合: L.174- UseWithWILSegmentation()
• パノプティックセグメンテーションの場合: L.174- UseWithWILSegmentation()
• 物体検出の場合: L.330- UseWithWILObjectDetection()
• マルチラベル画像分類の場合: L.42- UseWithWIL()

Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Linq
Imports FVIL
Imports FVIL.Data
Imports FVIL.PDL
 
Namespace SamplesCS
    Partial Class Program
        Private Shared Sub _predict(model As Model, targetImage As CFviImage)
            Select Case model.ModelCategory
                Case ModelCategory.Classification ' 画像分類
                    ' 推論実行
                    Dim scores = model.PredictClassification(targetImage)
 
                    ' スコアをコンソール出力
                    For i_score = 0 To scores.Length - 1
                        Console.WriteLine($"label{i_score}: {scores(i_score)}")
                    Next
                Case ModelCategory.AnomalyDetection ' アノマリー検出
                    ' 閾値を任意に設定して推論実行 ( double から float キャストに注意 )
                    Dim threshold = 10.0
                    Dim tuple = model.PredictAnomaly(targetImage, threshold)
 
                    ' コンソール出力
                    Dim str_is_anomaly = If(tuple.Item1, "anomaly", "normal")
                    Console.WriteLine($"{str_is_anomaly}, max_anomaly={tuple.Item2}")
                Case ModelCategory.MultiLabelClassification ' マルチラベル画像分類
                    ' 推論実行
                    Dim scores = model.PredictMultiLabelClassification(targetImage)
 
                    ' スコアをコンソール出力
                    For i_score = 0 To scores.Length - 1
                        Console.WriteLine($"label{i_score}: {scores(i_score)}")
                    Next
 
                Case Else
                    Throw New NotImplementedException($"unknwon model-category={model.ModelCategory}")
            End Select
        End Sub
        Private Shared Sub UseWithWIL(modelPath As String, imagePath As String)
            Try
                Dim has_license = PDL.Model.CheckLicense()
                If False = has_license Then
                    Throw New Exception("no license")
                End If
 
                ' モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Dim model As Model = New Model(modelPath)
 
                ' 推論対象画像の読込
                Dim image As CFviImage = New CFviImage(imagePath)
 
                ' 推論対象画像の有効性確認
                Dim is_valid_img = model.IsValidImage(image)
                If False = is_valid_img Then
                    Throw New Exception("invalid image")
                End If
 
                ' 元画像での推論
                Console.WriteLine("original image")
                _predict(model, image)
 
                ' 任意のフィルタ処理 ( ここでは例として単純な average フィルタ )
                Dim filtered_image = New CFviImage(image, False)
                Dim parser = New Filter.CFviAverageFilter()
                parser.SrcImages(0) = image
                parser.DstImages(0) = filtered_image
                If Not parser.IsValid() Then
                    parser.Validate()
                End If
                parser.Execute()
 
                ' 処理画像での推論
                Console.WriteLine("filtered image")
                _predict(model, filtered_image)
            Catch ex As CFviException
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            Catch ex As Exception
                Console.WriteLine($"Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            End Try
        End Sub
 
        Private Shared Sub _predictMultiView(model As Model, targetImages As IEnumerable(Of CFviImage))
            ' モデル種別のエラーチェック
            Select Case model.ModelCategory
                Case ModelCategory.MultiViewCNN
                    ' 推論実行
                    Dim scores = model.PredictMultiViewCNN(targetImages)
 
                    ' スコアをコンソール出力
                    For i_score = 0 To scores.Length - 1
                        Console.WriteLine($"label{i_score}: {scores(i_score)}")
                    Next
                Case ModelCategory.MultiViewAD
                    If True Then
                        ' 閾値を任意に設定して推論実行 ( double から float キャストに注意 )
                        Dim threshold = 10.0
                        Dim tuple = model.PredictMultiViewAD(targetImages, threshold)
 
                        ' コンソール出力
                        Dim str_is_anomaly = If(tuple.Item1, "anomaly", "normal")
                        Console.WriteLine($"{str_is_anomaly}, max_anomaly={tuple.Item2}")
                    End If
 
                Case Else
                    Throw New NotImplementedException($"unmatch model-category={model.ModelCategory}")
            End Select
 
        End Sub
        Private Shared Sub UseWithWILMultiImage(modelPath As String, imageFolder As String)
            Try
                Dim has_license = PDL.Model.CheckLicense()
                If False = has_license Then
                    Throw New Exception("no license")
                End If
 
                ' モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Dim model As Model = New Model(modelPath)
 
                ' 推論対象画像の読込と有効性の確認
                Dim original_images As List(Of CFviImage) = New List(Of CFviImage)()
                For i_img = 0 To model.NumViews - 1
                    ' imageFolder フォルダ内に、0-index の通し番号の画像が保存されていることを想定
                    Dim img_path = Path.Combine(imageFolder, String.Format("{0}.bmp", i_img))
                    Dim image = New CFviImage(img_path)
 
                    ' 推論対象画像の有効性確認
                    Dim is_valid_img = model.IsValidImage(image)
                    If False = is_valid_img Then
                        Throw New Exception("invalid image")
                    End If
 
                    ' 推論対象画像のリストに追加
                    original_images.Add(image)
                Next
 
                ' 元画像での推論
                Console.WriteLine("original image")
                _predictMultiView(model, original_images)
 
                ' 任意のフィルタ処理 ( ここでは例として単純な average フィルタ )
                Dim filtered_images As List(Of CFviImage) = New List(Of CFviImage)()
                Using parser = New Filter.CFviAverageFilter()
                    For Each src_image In original_images
                        Dim dst_image = New CFviImage(src_image.HorzSize, src_image.VertSize, src_image.ImageType, src_image.Channel)
 
                        parser.SrcImages(0) = src_image
                        parser.DstImages(0) = dst_image
                        If Not parser.IsValid() Then
                            parser.Validate()
                        End If
                        parser.Execute()
 
                        filtered_images.Add(dst_image)
                    Next
                End Using
 
                ' 処理画像での推論
                Console.WriteLine("filtered image")
                _predictMultiView(model, filtered_images)
            Catch ex As CFviException
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            Catch ex As Exception
                Console.WriteLine($"Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            End Try
        End Sub
 
        Private Shared Sub UseWithWILSegmentation(modelPath As String, imagePath As String, blobAreaMinThreshold As Double, blobAreaMaxThreshold As Double)
            Try
                Dim has_license = PDL.Model.CheckLicense()
                If False = has_license Then
                    Throw New Exception("no license")
                End If
 
                ' モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Dim model As Model = New Model(modelPath)
 
                ' 推論対象画像の読込
                Dim image As CFviImage = New CFviImage(imagePath)
 
                ' 推論対象画像の有効性確認
                Dim is_valid_img = model.IsValidImage(image)
                If False = is_valid_img Then
                    Throw New Exception("invalid image")
                End If
 
 
                Select Case model.ModelCategory
                    Case ModelCategory.SemanticSegmentation ' セマンティックセグメンテーション
                        ' 推論実行
                        Dim segm_result_image = model.PredictSemanticSegmentation(image)
 
                        ' 濃度値の最大が領域を検出できたカテゴリたちの中での最大の番号に相当
                        Dim max_posi = segm_result_image.FindMaxValue(0, 0)
                        Dim max_value = segm_result_image.GetPixelI32(0, max_posi.X, max_posi.Y)
                        If 0 = max_value Then ' 0 が最大値ということは 1 以上のピクセルが無い。つまり画像の全てが背景と判定されたとき
                            Console.WriteLine("all pixels are background")
                        End If
 
                        ' カテゴリの個数: 既知であればここで取得する必要は無い
                        Dim n_category = model.GetLabelList().Count()
 
                        ' 各カテゴリ ( ラベル ) の情報を取得: 0 番は背景に対応し、カテゴリ番号は 1-index であることに注意
                        For category_id = 1 To n_category
                            ' カテゴリ番号に一致するピクセルのみを 1 に、その他を 0 にすることで、そのカテゴリとして検出された領域の二値画像を取得
                            ' ※ PredictSemanticSegmentation(CFviImage targetImage, Dictionary<UInt32, CFviImage> categoryMaskImages) にて categoryMaskImages で取得できる二値画像に相当
                            Dim bin_mask = New CFviImage(segm_result_image.HorzSize, segm_result_image.VertSize, ImageType.BIN, 1, 1)
                            bin_mask.Window = segm_result_image.Window
                            Dim ret = fvalgcli.api.fnFIE_band_threshold(segm_result_image.GetFIEChild(), bin_mask.GetFIEChild(), category_id, category_id)
                            If fvalgcli.f_err.F_ERR_NONE <> ret Then
                                Throw New fvalgcli.FvException(ret)
                            End If
 
                            ' 検出した領域の二値画像に対してブローブ解析を実行
                            Dim blob_result = New Blob.CFviBlobResult()
                            Dim blob_param = New Blob.CFviBlobParam()
                            blob_param.ColorMode = Blob.ObjectColor.WhiteFG_BlackBG
                            blob_param.Neighborhood = Blob.Neighborhood.Eight
                            Dim blob_parser = New Blob.CFviBlob(bin_mask, blob_result, blob_param)
                            If Not blob_parser.IsValid() Then
                                blob_parser.Validate()
                            End If
                            blob_parser.Execute()
 
                            ' ブローブ解析の結果に対して、さらにフィルタリング ( ここでは面積 )
                            Dim filters = New List(Of Blob.CFviBlobFilterRange)()
                            filters.Add(New Blob.CFviBlobFilterRange(Blob.FeatureType.AREA, blobAreaMinThreshold, blobAreaMaxThreshold))
                            Dim blob_list = blob_result.GetBlobList(filters)
                            Console.WriteLine($"category_id={category_id}: blob count={blob_list.Count}")
                            For Each kv In blob_list
                                Dim blob_data = New Blob.CFviBlobData(kv)
                                ' 以下、ブローブ特徴量に基づく解析も可能
                            Next
 
                            ' 検出した領域の二値画像をリージョンに変換
                            Dim region_mask = New CFviRegion(bin_mask)
                            ' リージョン特徴量に基づく解析や、画像に対するリージョン内の特徴量の取得が可能
                            'var mean = FVIL.Region.Measure.MeanPixel(image, region_mask);// 例: 元画像のリージョン内の平均濃度値の取得
                        Next
                    Case ModelCategory.PanopticSegmentation
                        ' 推論実行
                        Dim segm_result_image = model.PredictPanopticSegmentation(image)
 
                        ' カテゴリ番号の格納された画像とインスタンス番号の格納された画像に分離
                        Dim category_map = New CFviImage(fvalgcli.api.fnFIE_img_child_alloc_single_ch(segm_result_image.GetFIERoot(), 0, 0, 0, segm_result_image.HorzSize, segm_result_image.VertSize), True)
                        Dim instance_map = New CFviImage(fvalgcli.api.fnFIE_img_child_alloc_single_ch(segm_result_image.GetFIERoot(), 1, 0, 0, segm_result_image.HorzSize, segm_result_image.VertSize), True)
                        category_map.Window = segm_result_image.Window
                        instance_map.Window = segm_result_image.Window
 
                        ' 濃度値の最大が検出した領域の個数に相当
                        Dim max_posi = instance_map.FindMaxValue(0, 0)
                        Dim max_value = instance_map.GetPixelI32(0, max_posi.X, max_posi.Y)
                        If 0 = max_value Then ' 0 が最大値ということは 1 以上のピクセルが無い。つまり画像の全てが背景と判定されたとき
                            Console.WriteLine("all pixels are background")
                        End If
 
                        ' 各検出領域の取得と、その領域に対する画像処理
                        For instance_id = 1 To max_value
                            ' 検出した領域の通し番号に一致するピクセルのみを 1 に、その他を 0 にすることで、その領域の二値画像を取得
                            Dim bin_mask = New CFviImage(instance_map.HorzSize, instance_map.VertSize, ImageType.BIN, 1, 1)
                            bin_mask.Window = instance_map.Window
                            Dim ret = fvalgcli.api.fnFIE_band_threshold(instance_map.GetFIEChild(), bin_mask.GetFIEChild(), instance_id, instance_id)
                            If fvalgcli.f_err.F_ERR_NONE <> ret Then
                                Throw New fvalgcli.FvException(ret)
                            End If
 
                            ' 検出した領域の二値画像に対してブローブ解析を実行 ( 物体毎に分離できているはずなので、各インスタンスの領域がそれ以上に分割されることはほとんど無いはず )
                            Dim blob_result = New Blob.CFviBlobResult()
                            Dim blob_param = New Blob.CFviBlobParam()
                            blob_param.ColorMode = Blob.ObjectColor.WhiteFG_BlackBG
                            blob_param.Neighborhood = Blob.Neighborhood.Eight
                            Dim blob_parser = New Blob.CFviBlob(bin_mask, blob_result, blob_param)
                            If Not blob_parser.IsValid() Then
                                blob_parser.Validate()
                            End If
                            blob_parser.Execute()
 
                            ' ブローブ解析の結果に対して、さらにフィルタリング ( ここでは面積 )
                            Dim filters = New List(Of Blob.CFviBlobFilterRange)()
                            filters.Add(New Blob.CFviBlobFilterRange(Blob.FeatureType.AREA, blobAreaMinThreshold, blobAreaMaxThreshold))
                            Dim blob_list = blob_result.GetBlobList(filters)
                            Console.WriteLine($"instance_id={instance_id}: blob count={blob_list.Count}")
                            For Each kv In blob_list
                                Dim blob_data = New Blob.CFviBlobData(kv)
 
                                Dim region = blob_data.GetRegion()
                                Dim category_id = CUInt(FVIL.Region.Measure.MaxPixel(category_map, region, OriginMode.Window)) ' max=min のはずで、領域をすべて見なくても 1 ピクセルを確認するのみでも良い
 
                                Console.WriteLine($"instance_id={instance_id}: category_id={category_id}, blob no={blob_data.BlobNo}")
 
                                ' 以下、ブローブ特徴量に基づく解析も可能
                            Next
 
                            ' 検出した領域の二値画像を直接リージョンに変換
                            Dim region_mask = New CFviRegion(bin_mask)
                            ' リージョン特徴量に基づく解析や、画像に対するリージョン内の特徴量の取得が可能
                            'var mean = FVIL.Region.Measure.MeanPixel(image, region_mask);// 例: 元画像のリージョン内の平均濃度値の取得
                        Next
 
                    Case Else
                        Throw New NotImplementedException($"unknwon model-category={model.ModelCategory}")
                End Select
            Catch ex As CFviException
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            Catch ex As Exception
                Console.WriteLine($"Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            End Try
        End Sub
 
        Private Shared Sub _predictObjectDetection(model As Model, targetImage As CFviImage)
            Select Case model.ModelCategory
                Case ModelCategory.ObjectDetection ' 物体検出
                    ' 推論実行
                    Dim detections = model.PredictObjectDetection(targetImage)
 
                    ' 検出数をコンソール出力
                    Console.WriteLine($"number of detections: {detections.Count()}")
                Case Else
                    Throw New NotImplementedException($"unknwon model-category={model.ModelCategory}")
            End Select
        End Sub
        Private Shared Sub UseWithWILObjectDetection(modelPath As String, imagePath As String)
            Try
                Dim has_license = PDL.Model.CheckLicense()
                If False = has_license Then
                    Throw New Exception("no license")
                End If
 
                ' モデルファイルの読込を含むコンストラクタ ( インスタンスを作成して LoadModel() をする場合と同等 )
                Dim model As Model = New Model(modelPath)
 
                ' 推論対象画像の読込
                Dim image As CFviImage = New CFviImage(imagePath)
 
                ' 推論対象画像の有効性確認
                Dim is_valid_img = model.IsValidImage(image)
                If False = is_valid_img Then
                    Throw New Exception("invalid image")
                End If
 
                ' 元画像での推論
                Console.WriteLine("original image")
                _predictObjectDetection(model, image)
 
                ' 任意のフィルタ処理 ( ここでは例として単純な average フィルタ )
                Dim filtered_image = New CFviImage(image, False)
                Dim parser = New Filter.CFviAverageFilter()
                parser.SrcImages(0) = image
                parser.DstImages(0) = filtered_image
                If Not parser.IsValid() Then
                    parser.Validate()
                End If
                parser.Execute()
 
                ' 処理画像での推論
                Console.WriteLine("filtered image")
                _predictObjectDetection(model, filtered_image)
            Catch ex As CFviException
                Console.WriteLine($"ErrorCode={ex.ErrorCode}, Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            Catch ex As Exception
                Console.WriteLine($"Message={ex.Message}")
                Console.WriteLine(ex.StackTrace)
            End Try
        End Sub
 
    End Class
End Namespace