halcon转c#后的模板

using HalconDotNet;//添加引用
using System;

namespace Halcon64
{

    public partial class ImageProcess1
    {
        private HTuple hv_image_flag = null;
        private HTuple hv_num_image = null;
        private HTuple hv_DLClassifierHandle = null;
        private HTuple hv_DlRangeMin = null;
        private HTuple hv_DlRangeMax = null;

        private HTuple hv_FileName = null;
        private HTuple hv_Runtime = null;


        /// <summary>
        /// 初始化全局变量
        /// 每一轮开始的时候调用
        /// </summary>
        public ImageProcess1()
        {
            //存放每个图片的类型
            HOperatorSet.TupleGenConst(6000, 0, out hv_image_flag);

            //num张图片统计一次
            HOperatorSet.TupleGenConst(1, 0, out hv_num_image);

            //模型参数
            HOperatorSet.TupleGenConst(1, 0, out hv_DLClassifierHandle);
            HOperatorSet.TupleGenConst(1, -127.0, out hv_DlRangeMin);
            HOperatorSet.TupleGenConst(1, 128.0, out hv_DlRangeMax);

            //模型存放地址（需要修改为对应的地址）
            hv_FileName = @"./model/best_model.hdl";
            hv_Runtime = "cpu";
            Init();//加载模型
        }

        /// <summary>
        /// 加载模型
        /// </summary>
        //private void Init()
        public void Init()
        {

            //加载模型
            HOperatorSet.ReadDlClassifier(hv_FileName, out hv_DLClassifierHandle);
            //单张图片测试
            HOperatorSet.SetDlClassifierParam(hv_DLClassifierHandle, "batch_size", 1);
            //测试是否可以在CPU环境下运行
            try
            {
                HOperatorSet.SetDlClassifierParam(hv_DLClassifierHandle, "runtime", "cpu");
                hv_Runtime = "cpu";
            }
            // catch (Exception) 
            catch (HalconException)
            {
                hv_Runtime = "gpu";
            }
            //设置超参数
            HOperatorSet.SetDlClassifierParam(hv_DLClassifierHandle, "runtime_init", "immediately");

        }

        /// <summary>
        /// 清除 复位
        /// </summary>
        public void Clear()
        {

            HOperatorSet.TupleGenConst(6000, 0, out hv_image_flag);

            HOperatorSet.TupleGenConst(1, 0, out hv_num_image);

            HOperatorSet.TupleGenConst(1, 0, out hv_DLClassifierHandle);
            HOperatorSet.TupleGenConst(1, -127.0, out hv_DlRangeMin);
            HOperatorSet.TupleGenConst(1, 128.0, out hv_DlRangeMax);
        }


        /// <summary>
        /// 主程序 
        /// 获取每张图片时调用
        /// </summary>
        public void Action(HObject ho_Image, HTuple hv_ImageID, out HTuple hv_flag, out HTuple hv_Exception)
        {
            // Stack for temporary objects 
            HObject[] OTemp = new HObject[20];

            // Local control variables 
            HTuple hv_Area = new HTuple(), hv_Area1 = new HTuple();
            HTuple hv_Number = new HTuple();
            HTuple hv_RescaleRange = new HTuple(), hv_Channel = new HTuple();
            HTuple hv_DLClassifierResultHandle = new HTuple(), hv_PredictedClass = new HTuple();
            // Initialize local and output iconic variables 
            HObject ho_Image1;
            HOperatorSet.GenEmptyObj(out ho_Image1);
            HObject ho_Region;
            HOperatorSet.GenEmptyObj(out ho_Region);
            HObject ho_ConnectedRegions;
            HOperatorSet.GenEmptyObj(out ho_ConnectedRegions);
            HObject ho_SelectedRegions;
            HOperatorSet.GenEmptyObj(out ho_SelectedRegions);

            //先赋值
            hv_flag = 0;
            hv_Exception = 0;
            try
            {
                //初始化输出变量

                hv_Area = 0;
                hv_Number = 0;
                using (HDevDisposeHelper dh = new HDevDisposeHelper())
                {
                    {
                        HTuple
                            ExpTmpLocalVar_num_image = hv_num_image + 1;
                        hv_num_image = ExpTmpLocalVar_num_image;
                    }
                }
                //存储
                ho_Image1 = new HObject(ho_Image);

                //**************【算法模型】*********************
                try
                {
                    //**************【1、图像预处理】*********************
                    //图像裁剪、缩放
                    {
                        HObject ExpTmpOutVar_0;
                        HOperatorSet.ZoomImageSize(ho_Image, out ExpTmpOutVar_0, 224, 224, "bilinear");
                        ho_Image = ExpTmpOutVar_0;
                    }
                    //将图像的灰度缩放成网络model需求范围
                    {
                        HObject ExpTmpOutVar_0;
                        HOperatorSet.ConvertImageType(ho_Image, out ExpTmpOutVar_0, "real");
                        ho_Image = ExpTmpOutVar_0;
                    }
                    using (HDevDisposeHelper dh = new HDevDisposeHelper())
                    {
                        hv_RescaleRange = (hv_DlRangeMax - hv_DlRangeMin) / 255.0;
                    }
                    //缩放图像的灰度值
                    {
                        HObject ExpTmpOutVar_0;
                        HOperatorSet.ScaleImage(ho_Image, out ExpTmpOutVar_0, hv_RescaleRange,
                            hv_DlRangeMin);
                        ho_Image = ExpTmpOutVar_0;
                    }
                    //如果图片不是三通道图，就需要将图像合成三通道图
                    HOperatorSet.CountChannels(ho_Image, out hv_Channel);
                    if ((int)(new HTuple(hv_Channel.TupleNotEqual(3))) != 0)
                    {
                        {
                            HObject ExpTmpOutVar_0;
                            HOperatorSet.Compose3(ho_Image, ho_Image, ho_Image, out ExpTmpOutVar_0
                                );
                            ho_Image = ExpTmpOutVar_0;
                        }
                    }
                    
                    //**************【2、图像检测】*********************
                    HOperatorSet.ApplyDlClassifier(ho_Image, hv_DLClassifierHandle, out hv_DLClassifierResultHandle);
                    HOperatorSet.GetDlClassifierResult(hv_DLClassifierResultHandle, "all",
                        "predicted_classes", out hv_PredictedClass);

                    //**************【3、输出结果】*********************
                    using (HDevDisposeHelper dh = new HDevDisposeHelper())
                    {
                        hv_flag = hv_image_flag.TupleSelect(
                            hv_ImageID);
                    }
                }
                catch (HalconException HDevExpDefaultException2)
                {
                    HDevExpDefaultException2.ToHTuple(out hv_Exception);
                    hv_flag = 5;
                }
            }
            catch (HalconException HDevExpDefaultException1)
            {
                HDevExpDefaultException1.ToHTuple(out hv_Exception);
                hv_flag = 6;
            }
            // 局部变量Dispose
            ho_Region.Dispose();
            ho_ConnectedRegions.Dispose();
            ho_SelectedRegions.Dispose();
            hv_Number.Dispose();
            hv_RescaleRange.Dispose();
            hv_Channel.Dispose();
            hv_DLClassifierResultHandle.Dispose();
            hv_PredictedClass.Dispose(); ;

        }

    }

}


public class HDevelopExportApp
{
    static void Main(string[] args)
    {
        string ID = null;
        string flag = null;
        HObject ho_Image;
        HTuple hv_ImagePath = new HTuple(), hv_ImageFiles = new HTuple();
        HTuple hv_ImageID = new HTuple();

        // Initialize local and output iconic variables 
        HOperatorSet.GenEmptyObj(out ho_Image);

        Halcon64.ImageProcess1 b = new Halcon64.ImageProcess1();

        //文件路径
        hv_ImagePath = @"./data";
        HOperatorSet.ListFiles(hv_ImagePath, (new HTuple("files")).TupleConcat("follow_links"),
            out hv_ImageFiles);
        for (hv_ImageID = 1; (int)hv_ImageID <= (int)((new HTuple(hv_ImageFiles.TupleLength()
            )) - 1); hv_ImageID = (int)hv_ImageID + 1)
        {
            //对每张图片处理
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                HOperatorSet.ReadImage(out ho_Image, hv_ImageFiles.TupleSelect(hv_ImageID));
                b.Action(ho_Image, hv_ImageID, out HTuple hv_flag, out HTuple hv_Exception);

                ID = hv_ImageID.ToString();
                flag = Convert.ToString(hv_flag[0].I);
                Console.WriteLine("ID:" + ID);
                Console.WriteLine("flag:" + flag);
            }
            
            ho_Image.Dispose();
            hv_ImagePath.Dispose();
            hv_ImageFiles.Dispose();
            hv_ImageID.Dispose();

        }
        Console.WriteLine("结束！");
        Console.ReadLine();



    }
}