SaveOutputParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
using System.IO;
 
namespace MyCaffe.param.ssd
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class SaveOutputParameter : OptionalParameter
    {
        string m_strOutputDirectory;
        string m_strOutputNamePrefix;
        OUTPUT_FORMAT m_outputFormat = OUTPUT_FORMAT.VOC;
        string m_strLabelMapFile;
        string m_strNameSizeFile;
        uint? m_nNumTestImage = null;
        ResizeParameter m_resizeParam = null;
 
        public enum OUTPUT_FORMAT
        {        
            VOC,
            COCO,
            ILSVRC
        }
 
        public SaveOutputParameter(bool bActive) : base(bActive)
        {
        }
 
        [Description("Specifies output directory, if not empty, the results will be saved.")]
        public string output_directory
        {
            get { return m_strOutputDirectory; }
            set { m_strOutputDirectory = value; }
        }
 
        [Description("Specifies output name prefix.")]
        public string output_name_prefix
        {
            get { return m_strOutputNamePrefix; }
            set { m_strOutputNamePrefix = value; }
        }
 
        [Description("Specifies output name prefix.")]
        public OUTPUT_FORMAT output_format
        {
            get { return m_outputFormat; }
            set { m_outputFormat = value; }
        }
 
        [Description("Optionally, specifies output label map file.")]
        public string label_map_file
        {
            get { return m_strLabelMapFile; }
            set { m_strLabelMapFile = value; }
        }
 
        [Description("Optionally, specifies output name size file.")]
        public string name_size_file
        {
            get { return m_strNameSizeFile; }
            set { m_strNameSizeFile = value; }
        }
 
        [Description("Specifies the number of test images, which can be less than the name_size_file line count.")]
        public uint? num_test_image
        {
            get { return m_nNumTestImage; }
            set { m_nNumTestImage = value; }
        }
 
        [Description("Specifies the resize parameter used in saving the data.")]
        public ResizeParameter resize_param
        {
            get { return m_resizeParam; }
            set { m_resizeParam = value; }
        }
 
        public SaveOutputParameter Load(BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            SaveOutputParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(OptionalParameter src)
        {
            base.Copy(src);
 
            if (src is SaveOutputParameter)
            {
                SaveOutputParameter p = (SaveOutputParameter)src;
 
                m_strOutputDirectory = p.m_strOutputDirectory;
                m_strOutputNamePrefix = p.m_strOutputNamePrefix;
                m_outputFormat = p.m_outputFormat;
                m_strLabelMapFile = p.m_strLabelMapFile;
                m_strNameSizeFile = p.m_strNameSizeFile;
                m_nNumTestImage = p.m_nNumTestImage;
 
                m_resizeParam = null;
                if (p.resize_param != null)
                    m_resizeParam = p.resize_param.Clone();
            }
        }
 
        public SaveOutputParameter Clone()
        {
            SaveOutputParameter p = new SaveOutputParameter(Active);
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProto rpBase = base.ToProto("option");
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(rpBase);
            rgChildren.Add(new RawProto("output_directory", m_strOutputDirectory));
            rgChildren.Add(new RawProto("output_name_prefix", m_strOutputNamePrefix));
            rgChildren.Add(new RawProto("output_format", m_outputFormat.ToString()));
            rgChildren.Add(new RawProto("label_map_file", m_strLabelMapFile));
            rgChildren.Add(new RawProto("name_size_file", m_strNameSizeFile));
 
            if (m_nNumTestImage.HasValue)
                rgChildren.Add(new RawProto("num_test_image", m_nNumTestImage.Value.ToString()));
 
            if (resize_param != null)
                rgChildren.Add(resize_param.ToProto("resize_param"));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new SaveOutputParameter FromProto(RawProto rp)
        {
            SaveOutputParameter p = new SaveOutputParameter(false);
            string strVal;
 
            RawProto rpOption = rp.FindChild("option");
            if (rpOption != null)
                ((OptionalParameter)p).Copy(OptionalParameter.FromProto(rpOption));
 
            if ((strVal = rp.FindValue("output_directory")) != null)
                p.output_directory = strVal;
 
            if ((strVal = rp.FindValue("output_name_prefix")) != null)
                p.output_name_prefix = strVal;
 
            if ((strVal = rp.FindValue("output_format")) != null)
            {
                if (strVal == OUTPUT_FORMAT.VOC.ToString())
                    p.output_format = OUTPUT_FORMAT.VOC;
                else if (strVal == OUTPUT_FORMAT.COCO.ToString())
                    p.output_format = OUTPUT_FORMAT.COCO;
                else
                    throw new Exception("Unknown output_format '" + strVal + "'!");
            }
 
            if ((strVal = rp.FindValue("label_map_file")) != null)
                p.label_map_file = strVal;
 
            if ((strVal = rp.FindValue("name_size_file")) != null)
                p.name_size_file = strVal;
 
            if ((strVal = rp.FindValue("num_test_image")) != null)
                p.num_test_image = uint.Parse(strVal);
 
            RawProto rpResize = rp.FindChild("resize_param");
            if (rpResize != null)
                p.resize_param = ResizeParameter.FromProto(rpResize);
 
            return p;
        }
    }
}