BatchSampler.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 BatchSampler : BaseParameter, ICloneable, IComparable, IBinaryPersist
    {
        bool m_bUseOriginalImage = true;
        Sampler m_sampler = new Sampler();
        SamplerConstraint m_constraint = new SamplerConstraint();
        uint m_nMaxSample = 0;
        uint m_nMaxTrials = 100;
 
        public BatchSampler()
        {
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write(m_bUseOriginalImage);
            bw.Write(m_nMaxSample);
            bw.Write(m_nMaxTrials);
            m_sampler.Save(bw);
            m_constraint.Save(bw);
        }
 
        public object Load(BinaryReader br, bool bNewInstance)
        {
            BatchSampler b = this;
            
            if (bNewInstance)
                b = new BatchSampler();
 
            m_bUseOriginalImage = br.ReadBoolean();
            m_nMaxSample = br.ReadUInt32();
            m_nMaxTrials = br.ReadUInt32();
            m_sampler = Sampler.Load(br);
            m_constraint = SamplerConstraint.Load(br);
 
            return b;
        }
 
        public static BatchSampler Load(BinaryReader br)
        {
            BatchSampler b = new BatchSampler();
            return (BatchSampler)b.Load(br, true);
        }
 
        public bool use_original_image
        {
            get { return m_bUseOriginalImage; }
            set { m_bUseOriginalImage = value; }
        }
 
        public uint max_sample
        {
            get { return m_nMaxSample; }
            set { m_nMaxSample = value; }
        }
 
        public uint max_trials
        {
            get { return m_nMaxTrials; }
            set { m_nMaxTrials = value; }
        }
 
        public Sampler sampler
        {
            get { return m_sampler; }
            set { m_sampler = value; }
        }
 
        public SamplerConstraint sample_constraint
        {
            get { return m_constraint; }
            set { m_constraint = value; }
        }
 
        public BatchSampler Clone()
        {
            BatchSampler bs = new BatchSampler();
 
            bs.m_bUseOriginalImage = m_bUseOriginalImage;
            bs.m_nMaxSample = m_nMaxSample;
            bs.m_nMaxTrials = m_nMaxTrials;
            bs.m_sampler = m_sampler.Clone();
            bs.m_constraint = m_constraint.Clone();
 
            return bs;
        }
 
        object ICloneable.Clone()
        {
            return Clone();
        }
 
        public bool Compare(BatchSampler bs)
        {
            if (bs.m_bUseOriginalImage != m_bUseOriginalImage)
                return false;
 
            if (bs.m_nMaxSample != m_nMaxSample)
                return false;
 
            if (bs.m_nMaxTrials != m_nMaxTrials)
                return false;
 
            if (!bs.m_sampler.Compare(m_sampler))
                return false;
 
            if (!bs.m_constraint.Compare(m_constraint))
                return true;
 
            return true;
        }
 
        public int CompareTo(object obj)
        {
            BatchSampler bs = obj as BatchSampler;
 
            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("use_original_image", m_bUseOriginalImage.ToString()));
            rgChildren.Add(new RawProto("max_sample", m_nMaxSample.ToString()));
            rgChildren.Add(new RawProto("max_trials", m_nMaxTrials.ToString()));
 
            rgChildren.Add(m_sampler.ToProto("sampler"));
            rgChildren.Add(m_constraint.ToProto("sample_constraint"));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static BatchSampler FromProto(RawProto rp)
        {
            string strVal;
            BatchSampler p = new BatchSampler();
 
            if ((strVal = rp.FindValue("use_original_image")) != null)
                p.use_original_image = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("max_sample")) != null)
                p.max_sample = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("max_trials")) != null)
                p.max_trials = uint.Parse(strVal);
 
            RawProto protoSampler = rp.FindChild("sampler");
            if (protoSampler != null)
                p.sampler = Sampler.FromProto(protoSampler);
 
            RawProto protoConstraint = rp.FindChild("sample_constraint");
            if (protoConstraint != null)
                p.sample_constraint = SamplerConstraint.FromProto(protoConstraint);
 
            return p;
        }
 
        public override string ToString()
        {
            string strOut = "";
 
            strOut += "use_original_image = " + use_original_image.ToString() + Environment.NewLine;
            strOut += "max_sample = " + max_sample.ToString() + Environment.NewLine;
            strOut += "max_trials = " + max_trials.ToString() + Environment.NewLine;
            strOut += m_sampler.ToString();
            strOut += m_constraint.ToString();
 
            return strOut;
        }
    }
}