LabelMap.cs

using MyCaffe.basecode;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.param.ssd
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class LabelMap
    {
        List<LabelMapItem> m_rgItems = new List<LabelMapItem>();
 
        public LabelMap()
        {
        }
 
        public LabelMapItem FindByLabel(int nLabel)
        {
            foreach (LabelMapItem li in m_rgItems)
            {
                if (li.label == nLabel)
                    return li;
            }
 
            return null;
        }
 
        public LabelMapItem FindByName(string strName)
        {
            foreach (LabelMapItem li in m_rgItems)
            {
                if (li.name == strName)
                    return li;
            }
 
            return null;
        }
 
        public Dictionary<int, string> MapToName(Log log, bool bStrict, bool bDisplayName)
        {
            Dictionary<int, string> rgLabelToName = new Dictionary<int, string>();
 
            for (int i = 0; i < m_rgItems.Count; i++)
            {
                string strName = (bDisplayName) ? m_rgItems[i].display : m_rgItems[i].name;
                int nLabel = m_rgItems[i].label;
 
                if (bStrict)
                {
                    if (rgLabelToName.ContainsKey(nLabel))
                        log.FAIL("There are duplicates of the label: " + nLabel.ToString());
 
                    rgLabelToName.Add(nLabel, strName);
                }
                else
                {
                    if (rgLabelToName.ContainsKey(nLabel))
                        rgLabelToName[nLabel] = strName;
                    else
                        rgLabelToName.Add(nLabel, strName);
                }
            }
 
            return rgLabelToName;
        }
 
        public Dictionary<string, int> MapToLabel(Log log, bool bStrict)
        {
            Dictionary<string, int> rgNameToLabel = new Dictionary<string, int>();
 
            for (int i = 0; i < m_rgItems.Count; i++)
            {
                string strName = m_rgItems[i].name;
                int nLabel = m_rgItems[i].label;
 
                if (bStrict)
                {
                    if (rgNameToLabel.ContainsKey(strName))
                        log.FAIL("There are duplicates of the name: " + strName.ToLower());
 
                    rgNameToLabel.Add(strName, nLabel);
                }
                else
                {
                    if (rgNameToLabel.ContainsKey(strName))
                        rgNameToLabel[strName] = nLabel;
                    else
                        rgNameToLabel.Add(strName, nLabel);
                }
            }
 
            return rgNameToLabel;
        }
 
        public List<LabelMapItem> item
        {
            get { return m_rgItems; }
        }
 
        public void Copy(LabelMap src)
        {
            m_rgItems = new List<LabelMapItem>();
 
            foreach (LabelMapItem item in src.item)
            {
                m_rgItems.Add(item.Clone());
            }
        }
 
        public LabelMap Clone()
        {
            LabelMap p = new LabelMap();
            p.Copy(this);
            return p;
        }
 
        public RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            RawProtoCollection col = new RawProtoCollection();
            foreach (LabelMapItem item in m_rgItems)
            {
                col.Add(item.ToProto("item"));
            }
 
            rgChildren.Add(col);
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static LabelMap FromProto(RawProto rp)
        {
            LabelMap p = new LabelMap();
 
            RawProtoCollection col = rp.FindChildren("item");
            foreach (RawProto child in col)
            {
                LabelMapItem item = LabelMapItem.FromProto(child);
                p.item.Add(item);
            }
 
            return p;
        }
    }
 
    public class LabelMapItem
    {
        string m_strName;
        string m_strDisplay;
        int m_nLabel;
 
        public LabelMapItem(int nLabel = 0, string strName = null, string strDisplay = null)
        {
            m_strName = strName;
            m_nLabel = nLabel;
            m_strDisplay = strDisplay;
        }
 
        public string name
        {
            get { return m_strName; }
            set { m_strName = value; }
        }
 
        public string display
        {
            get { return m_strDisplay; }
            set { m_strDisplay = value; }
        }
 
        public int label
        {
            get { return m_nLabel; }
            set { m_nLabel = value; }
        }
 
        public void Copy(LabelMapItem src)
        {
            m_strName = src.m_strName;
            m_strDisplay = src.m_strDisplay;
            m_nLabel = src.m_nLabel;
        }
 
        public LabelMapItem Clone()
        {
            return new LabelMapItem(m_nLabel, m_strName, m_strDisplay);
        }
 
        public RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(new RawProto("name", m_strName));
            rgChildren.Add(new RawProto("label", m_nLabel.ToString()));
 
            if (!string.IsNullOrEmpty(m_strDisplay))
                rgChildren.Add(new RawProto("display", m_strDisplay));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static LabelMapItem FromProto(RawProto rp)
        {
            LabelMapItem item = new LabelMapItem();
            string strVal;
 
            if ((strVal = rp.FindValue("name")) != null)
                item.name = strVal;
 
            if ((strVal = rp.FindValue("label")) != null)
                item.label = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("display")) != null)
                item.display = strVal;
 
            return item;
        }
    }
}