BlobProto.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using MyCaffe.basecode;
using MyCaffe.common;
 
namespace MyCaffe.param
{
    public class BlobProto : BaseParameter, ICloneable, IComparable, IBinaryPersist  
    {
        BlobShape m_rgShape = null;
        List<double> m_rgdfData = new List<double>();
        List<double> m_rgdfDiff = new List<double>();
        List<float> m_rgfData = new List<float>();
        List<float> m_rgfDiff = new List<float>();
 
        // 4D dimensions -- depreciated.  Use 'shape' instead.
        int? m_nNum = null;
        int? m_nChannels = null;
        int? m_nHeight = null;
        int? m_nWidth = null;
 
        public BlobProto()
        {
        }
 
        public BlobProto(List<int> rgShape)
        {
            m_rgShape = new BlobShape(rgShape);
        }
 
        public void Save(BinaryWriter bw)
        {
            bool bHasShape = (m_rgShape != null) ? true : false;
 
            bw.Write(bHasShape);
            if (bHasShape)
                m_rgShape.Save(bw);
 
            Utility.Save<double>(bw, m_rgdfData);
            Utility.Save<double>(bw, m_rgdfDiff);
            Utility.Save<float>(bw, m_rgfData);
            Utility.Save<float>(bw, m_rgfDiff);
 
            bw.Write(m_nNum.HasValue);
            if (m_nNum.HasValue)
                bw.Write(m_nNum.Value);
 
            bw.Write(m_nChannels.HasValue);
            if (m_nChannels.HasValue)
                bw.Write(m_nChannels.Value);
 
            bw.Write(m_nHeight.HasValue);
            if (m_nHeight.HasValue)
                bw.Write(m_nHeight.Value);
 
            bw.Write(m_nWidth.HasValue);
            if (m_nWidth.HasValue)
                bw.Write(m_nWidth.Value);
        }
 
        public object Load(BinaryReader br, bool bNewInstance)
        {
            BlobProto p = this;
 
                p = new BlobProto();
 
            if (br.ReadBoolean())
                p.m_rgShape = BlobShape.Load(br);
 
            p.m_rgdfData = Utility.Load<double>(br);
            p.m_rgdfDiff = Utility.Load<double>(br);
            p.m_rgfData = Utility.Load<float>(br);
            p.m_rgfDiff = Utility.Load<float>(br);
 
            if (br.ReadBoolean())
                p.m_nNum = br.ReadInt32();
 
            if (br.ReadBoolean())
                p.m_nChannels = br.ReadInt32();
 
            if (br.ReadBoolean())
                p.m_nHeight = br.ReadInt32();
 
            if (br.ReadBoolean())
                p.m_nWidth = br.ReadInt32();
 
            return p;
        }
 
        public BlobShape shape
        {
            get { return m_rgShape; }
            set { m_rgShape = value; }
        }
 
        public int? num
        {
            get { return m_nNum; }
            set { m_nNum = value; }
        }
 
        public int? channels
        {
            get { return m_nChannels; }
            set { m_nChannels = value; }
        }
 
        public int? height
        {
            get { return m_nHeight; }
            set { m_nHeight = value; }
        }
 
        public int? width
        {
            get { return m_nWidth; }
            set { m_nWidth = value; }
        }
 
        public List<double> double_data
        {
            get { return m_rgdfData; }
            set { m_rgdfData = value; }
        }
 
        public List<double> double_diff
        {
            get { return m_rgdfDiff; }
            set { m_rgdfDiff = value; }
        }
 
        public List<float> data
        {
            get { return m_rgfData; }
            set { m_rgfData = value; }
        }
 
        public List<float> diff
        {
            get { return m_rgfDiff; }
            set { m_rgfDiff = value; }
        }
 
        public object Clone()
        {
            BlobProto bp = new BlobProto(m_rgShape.dim);
 
            bp.m_rgdfData = Utility.Clone<double>(m_rgdfData);
            bp.m_rgdfDiff = Utility.Clone<double>(m_rgdfDiff);
            bp.m_rgfData = Utility.Clone<float>(m_rgfData);
            bp.m_rgfDiff = Utility.Clone<float>(m_rgfDiff);
            bp.num = num;
            bp.channels = channels;
            bp.height = height;
            bp.width = width;
 
            return bp;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            if (shape != null)
                rgChildren.Add(shape.ToProto("shape"));
 
            rgChildren.Add("num", num);
            rgChildren.Add("channels", channels);
            rgChildren.Add("height", height);
            rgChildren.Add("width", width);
            rgChildren.Add<double>("double_data", double_data);
            rgChildren.Add<double>("double_diff", double_diff);
            rgChildren.Add<float>("data", data);
            rgChildren.Add<float>("diff", diff);
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static BlobProto FromProto(RawProto rp)
        {
            BlobProto p = new BlobProto();
 
            RawProto rpShape = rp.FindChild("shape");
            if (rpShape != null)
                p.shape = BlobShape.FromProto(rpShape);
 
            p.num = (int?)rp.FindValue("num", typeof(int));
            p.channels = (int?)rp.FindValue("channels", typeof(int));
            p.height = (int?)rp.FindValue("height", typeof(int));
            p.width = (int?)rp.FindValue("width", typeof(int));
            p.double_data = rp.FindArray<double>("double_data");
            p.double_diff = rp.FindArray<double>("double_diff");
            p.data = rp.FindArray<float>("data");
            p.diff = rp.FindArray<float>("diff");
 
            return p;
        }
 
        public int CompareTo(object obj)
        {
            BlobProto bp = obj as BlobProto;
 
            if (bp == null)
                return 1;
 
            if (!Compare(bp))
                return 1;
 
            return 0;
        }
 
        public static BlobProto Load(BinaryReader br)
        {
            BlobProto b = new BlobProto();
            return (BlobProto)b.Load(br, true);
        }
    }
}