ResizeParameter.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MyCaffe.basecode;
 
namespace MyCaffe.param.ssd
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class ResizeParameter : OptionalParameter
    {
        float m_fProb = 0;
        ResizeMode m_mode = ResizeMode.WARP;
        PadMode m_pad = PadMode.CONSTANT;
        List<InterpMode> m_rgInterp = new List<InterpMode>();
        uint m_nHeight = 0;
        uint m_nWidth = 0;
        uint m_nHeightScale = 0;
        uint m_nWidthScale = 0;
        List<float> m_rgfPadValue = new List<float>();
 
        public enum ResizeMode
        {
            WARP = 1,
            FIT_SMALL_SIZE = 2,
            FIT_LARGE_SIZE_AND_PAD = 3
        }
 
        public enum PadMode
        {
            CONSTANT = 1,
            MIRRORED = 2,
            REPEAT_NEAREST = 3
        }
 
        public enum InterpMode
        {
            LINEAR = 1,
            AREA = 2,
            NEAREST = 3,
            CUBIC = 4,
            LANCZOS4 = 5
        }
 
        public ResizeParameter(bool bActive) : base(bActive)
        {
        }
 
        [Description("Get/set probability of using this resize policy.")]
        public float prob
        {
            get { return m_fProb; }
            set { m_fProb = value; }
        }
 
        [Description("Get/set the resizing mode.")]
        public ResizeMode resize_mode
        {
            get { return m_mode; }
            set { m_mode = value; }
        }
 
        [Description("Get/set the resizing height.")]
        public uint height
        {
            get { return m_nHeight; }
            set { m_nHeight = value; }
        }
 
        [Description("Get/set the resizing width.")]
        public uint width
        {
            get { return m_nWidth; }
            set { m_nWidth = value; }
        }
 
        [Description("Get/set the resizing height scale used with FIT_SMALL_SIZE mode.")]
        public uint height_scale
        {
            get { return m_nHeightScale; }
            set { m_nHeightScale = value; }
        }
 
        [Description("Get/set the resizing width scale used with FIT_SMALL_SIZE_mode.")]
        public uint width_scale
        {
            get { return m_nWidthScale; }
            set { m_nWidthScale = value; }
        }
 
        [Description("Get/set the pad mode for FIT_LARGE_SIZE_AND_PAD mode.")]
        public PadMode pad_mode
        {
            get { return m_pad; }
            set { m_pad = value; }
        }
 
        [Description("Get/set the pad value which is repeated once for all channels, or provided one pad value per channel.")]
        public List<float> pad_value
        {
            get { return m_rgfPadValue; }
            set { m_rgfPadValue = value; }
        }
 
        [Description("Get/set the interp mode which is repeated once for all channels, or provided once per channel.")]
        public List<InterpMode> interp_mode
        {
            get { return m_rgInterp; }
            set { m_rgInterp = value; }
        }
 
 
        public ResizeParameter Load(BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            ResizeParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(OptionalParameter src)
        {
            base.Copy(src);
 
            if (src is ResizeParameter)
            {
                ResizeParameter p = (ResizeParameter)src;
                m_fProb = p.prob;
                m_mode = p.resize_mode;
                m_pad = p.pad_mode;
 
                m_rgInterp = new List<InterpMode>();
                foreach (InterpMode interp in p.m_rgInterp)
                {
                    m_rgInterp.Add(interp);
                }
 
                m_nHeight = p.height;
                m_nWidth = p.width;
                m_nHeightScale = p.height_scale;
                m_nWidthScale = p.width_scale;
 
                m_rgfPadValue = new List<float>();
                foreach (float fPad in p.pad_value)
                {
                    m_rgfPadValue.Add(fPad);
                }
            }
        }
 
        public ResizeParameter Clone()
        {
            ResizeParameter p = new param.ssd.ResizeParameter(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("active", Active.ToString()));
            rgChildren.Add(new RawProto("prob", prob.ToString()));
            rgChildren.Add(new RawProto("resize_mode", m_mode.ToString()));
            rgChildren.Add(new RawProto("pad_mode", m_pad.ToString()));
            rgChildren.Add(new RawProto("height", m_nHeight.ToString()));
            rgChildren.Add(new RawProto("width", m_nWidth.ToString()));
            rgChildren.Add(new RawProto("height_scale", m_nHeightScale.ToString()));
            rgChildren.Add(new RawProto("width_scale", m_nWidthScale.ToString()));
 
            foreach (InterpMode interp in m_rgInterp)
            {
                rgChildren.Add(new RawProto("interp_mode", interp.ToString()));
            }
 
            foreach (float fPad in m_rgfPadValue)
            {
                rgChildren.Add(new RawProto("pad_value", fPad.ToString()));
            }
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new ResizeParameter FromProto(RawProto rp)
        {
            ResizeParameter p = new ResizeParameter(false);
            string strVal;
 
            RawProto rpOption = rp.FindChild("option");
            if (rpOption != null)
                ((OptionalParameter)p).Copy(OptionalParameter.FromProto(rpOption));
 
            if ((strVal = rp.FindValue("active")) != null)
                p.Active = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("prob")) != null)
                p.prob = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("resize_mode")) != null)
            {
                switch (strVal)
                {
                    case "WARP":
                        p.resize_mode = ResizeMode.WARP;
                        break;
 
                    case "FIT_SMALL_SIZE":
                        p.resize_mode = ResizeMode.FIT_SMALL_SIZE;
                        break;
 
                    case "FIT_LARGE_SIZE_AND_PAD":
                        p.resize_mode = ResizeMode.FIT_LARGE_SIZE_AND_PAD;
                        break;
 
                    default:
                        throw new Exception("Unknown resize_mode '" + strVal + "'!");
                }
            }
 
            if ((strVal = rp.FindValue("height")) != null)
                p.height = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("width")) != null)
                p.width = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("height_scale")) != null)
                p.height_scale = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("width_scale")) != null)
                p.width_scale = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("pad_mode")) != null)
            {
                switch (strVal)
                {
                    case "CONSTANT":
                        p.pad_mode = PadMode.CONSTANT;
                        break;
 
                    case "MIRRORED":
                        p.pad_mode = PadMode.MIRRORED;
                        break;
 
                    case "REPEAT_NEAREST":
                        p.pad_mode = PadMode.REPEAT_NEAREST;
                        break;
 
                    default:
                        throw new Exception("Unknown pad_mode '" + strVal + "'!");
                }
            }
 
            p.pad_value = new List<float>();
            RawProtoCollection col = rp.FindChildren("pad_value");
            foreach (RawProto rp1 in col)
            {
                if ((strVal = rp.FindValue("pad_value")) != null)
                    p.pad_value.Add(BaseParameter.ParseFloat(strVal));
            }
 
            p.interp_mode = new List<InterpMode>();
            RawProtoCollection col1 = rp.FindChildren("interp_mode");
            foreach (RawProto pr1 in col1)
            {
                strVal = pr1.Value;
 
                switch (strVal)
                {
                    case "LINEAR":
                        p.interp_mode.Add(InterpMode.LINEAR);
                        break;
                
                    case "AREA":
                        p.interp_mode.Add(InterpMode.AREA);
                        break;
                
                    case "NEAREST":
                        p.interp_mode.Add(InterpMode.NEAREST);
                        break;
                
                    case "CUBIC":
                        p.interp_mode.Add(InterpMode.CUBIC);
                        break;
                
                    case "LANCZOS4":
                        p.interp_mode.Add(InterpMode.LANCZOS4);
                        break;
                
                    default:
                        throw new Exception("Unknown interp_mode '" + strVal + "'!");
                }
            }
 
            return p;
        }
    }
}