Sampler.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using MyCaffe.basecode;
using MyCaffe.common;
using System.ComponentModel;
 
namespace MyCaffe.param.ssd
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class Sampler : BaseParameter, ICloneable, IComparable, IBinaryPersist
    {
        float m_fMinScale = 1.0f;
        float m_fMaxScale = 1.0f;
        float m_fMinAspectRatio = 1.0f;
        float m_fMaxAspectRatio = 1.0f;
 
        public Sampler()
        {
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write(m_fMinScale);
            bw.Write(m_fMaxScale);
            bw.Write(m_fMinAspectRatio);
            bw.Write(m_fMaxAspectRatio);
        }
 
        public object Load(BinaryReader br, bool bNewInstance)
        {
            Sampler b = this;
            
            if (bNewInstance)
                b = new Sampler();
 
            b.m_fMinScale = br.ReadSingle();
            b.m_fMaxScale = br.ReadSingle();
            b.m_fMinAspectRatio = br.ReadSingle();
            b.m_fMaxAspectRatio = br.ReadSingle();
 
            return b;
        }
 
        public static Sampler Load(BinaryReader br)
        {
            Sampler b = new Sampler();
            return (Sampler)b.Load(br, true);
        }
 
        public float min_scale
        {
            get { return m_fMinScale; }
            set { m_fMinScale = value; }
        }
 
        public float max_scale
        {
            get { return m_fMaxScale; }
            set { m_fMaxScale = value; }
        }
 
        public float min_aspect_ratio
        {
            get { return m_fMinAspectRatio; }
            set { m_fMinAspectRatio = value; }
        }
 
        public float max_aspect_ratio
        {
            get { return m_fMaxAspectRatio; }
            set { m_fMaxAspectRatio = value; }
        }
 
        public Sampler Clone()
        {
            Sampler bs = new Sampler();
 
            bs.m_fMinScale = m_fMinScale;
            bs.m_fMaxScale = m_fMaxScale;
            bs.m_fMinAspectRatio = m_fMinAspectRatio;
            bs.m_fMaxAspectRatio = m_fMaxAspectRatio;
 
            return bs;
        }
 
        object ICloneable.Clone()
        {
            return Clone();
        }
 
        public bool Compare(Sampler bs)
        {
            if (bs.m_fMinScale != m_fMinScale)
                return false;
            if (bs.m_fMaxScale != m_fMaxScale)
                return false;
 
            if (bs.m_fMinAspectRatio != m_fMinAspectRatio)
                return false;
            if (bs.m_fMaxAspectRatio != m_fMaxAspectRatio)
                return false;
 
            return true;
        }
 
        public int CompareTo(object obj)
        {
            Sampler bs = obj as Sampler;
 
            if (bs == null)
                return 1;
 
            if (!Compare(bs))
                return 1;
 
            return 0;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(new RawProto("min_scale", m_fMinScale.ToString()));
            rgChildren.Add(new RawProto("max_scale", m_fMaxScale.ToString()));
            rgChildren.Add(new RawProto("min_aspect_ratio", m_fMinAspectRatio.ToString()));
            rgChildren.Add(new RawProto("max_aspect_ratio", m_fMaxAspectRatio.ToString()));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static Sampler FromProto(RawProto rp)
        {
            string strVal;
            Sampler p = new Sampler();
 
            if ((strVal = rp.FindValue("min_scale")) != null)
                p.min_scale = BaseParameter.ParseFloat(strVal);
            if ((strVal = rp.FindValue("max_scale")) != null)
                p.max_scale = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("min_aspect_ratio")) != null)
                p.min_aspect_ratio = BaseParameter.ParseFloat(strVal);
            if ((strVal = rp.FindValue("max_aspect_ratio")) != null)
                p.max_aspect_ratio = BaseParameter.ParseFloat(strVal);
 
            return p;
        }
 
        public override string ToString()
        {
            string strOut = "";
 
            strOut += "min_scale = " + min_scale.ToString() + Environment.NewLine;
            strOut += "max_scale = " + max_scale.ToString() + Environment.NewLine;
            strOut += "min_aspect_ratio = " + min_aspect_ratio.ToString() + Environment.NewLine;
            strOut += "max_aspect_ratio = " + max_aspect_ratio.ToString() + Environment.NewLine;
 
            return strOut;
        }
    }
}