MaskParameter.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
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class MaskParameter : OptionalParameter
    {        
        int m_nMaskLeft = 0;
        int m_nMaskRight = 0;
        int m_nMaskTop = 0;
        int m_nMaskBottom = 0;
 
        public MaskParameter(bool bActive) : base(bActive)
        {
        }
 
        [Description("Defines the left side of the masked boundary where 'x' positions >= this value are masked.")]
        public int boundary_left
        {
            get { return m_nMaskLeft; }
            set { m_nMaskLeft = value; }
        }
 
        [Description("Defines the right side of the masked boundary where 'x' positions <= this value are masked.")]
        public int boundary_right
        {
            get { return m_nMaskRight; }
            set { m_nMaskRight = value; }
        }
 
        [Description("Defines the top side of the masked boundary where 'y' positions >= this value are masked.")]
        public int boundary_top
        {
            get { return m_nMaskTop; }
            set { m_nMaskTop = value; }
        }
 
        [Description("Defines the bottom side of the masked boundary where 'y' positions <= this value are masked.")]
        public int boundary_bottom
        {
            get { return m_nMaskBottom; }
            set { m_nMaskBottom = value; }
        }
 
 
        public MaskParameter Load(BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            MaskParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(OptionalParameter src)
        {
            base.Copy(src);
 
            if (src is MaskParameter)
            {
                MaskParameter p = (MaskParameter)src;
                m_nMaskLeft = p.m_nMaskLeft;
                m_nMaskRight = p.m_nMaskRight;
                m_nMaskTop = p.m_nMaskTop;
                m_nMaskBottom = p.m_nMaskBottom;
            }
        }
 
        public MaskParameter Clone()
        {
            MaskParameter p = new MaskParameter(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("boundary_left", boundary_left.ToString()));
            rgChildren.Add(new RawProto("boundary_right", boundary_right.ToString()));
            rgChildren.Add(new RawProto("boundary_top", boundary_top.ToString()));
            rgChildren.Add(new RawProto("boundary_bottom", boundary_bottom.ToString()));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new MaskParameter FromProto(RawProto rp)
        {
            MaskParameter p = new MaskParameter(true);
            string strVal;
 
            RawProto rpOption = rp.FindChild("option");
            if (rpOption != null)
                ((OptionalParameter)p).Copy(OptionalParameter.FromProto(rpOption));
 
            if ((strVal = rp.FindValue("boundary_left")) != null)
                p.boundary_left = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("boundary_right")) != null)
                p.boundary_right = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("boundary_top")) != null)
                p.boundary_top = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("boundary_bottom")) != null)
                p.boundary_bottom = int.Parse(strVal);
 
            return p;
        }
    }
}