LabelMapping.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.basecode
{
    [Serializable]
    public class LabelMappingCollection : IEnumerable<LabelMapping>
    {
        List<LabelMapping> m_rgMappings = new List<LabelMapping>();
 
        public LabelMappingCollection()
        {
        }
 
        public int Count
        {
            get { return m_rgMappings.Count; }
        }
 
        public List<LabelMapping> Mappings
        {
            get { return m_rgMappings; }
            set { m_rgMappings = value.OrderBy(p => p.OriginalLabel).ToList(); }
        }
 
        public LabelMapping this[int nIdx]
        {
            get { return m_rgMappings[nIdx]; }
            set { m_rgMappings[nIdx] = value; }
        }
 
        public void Add(LabelMapping map)
        {
            foreach (LabelMapping m in m_rgMappings)
            {
                if (m.OriginalLabel == map.OriginalLabel && m.ConditionBoostEquals == map.ConditionBoostEquals)
                    throw new Exception("You already have a mapping for the original label '" + map.OriginalLabel.ToString() + "' with the conditional boost = '" + map.ConditionBoostEquals.ToString() + "'.");
            }
 
            m_rgMappings.Add(map);
            m_rgMappings = m_rgMappings.OrderBy(p => p.OriginalLabel).ToList();
        }
 
        public bool Remove(LabelMapping map)
        {
            return m_rgMappings.Remove(map);
        }
 
        public LabelMappingCollection Clone()
        {
            LabelMappingCollection col = new LabelMappingCollection();
 
            foreach (LabelMapping m in m_rgMappings)
            {
                col.Add(m.Clone());
            }
 
            return col;
        }
 
        public int MapLabel(int nLabel, int nBoost)
        {
            foreach (LabelMapping m in m_rgMappings)
            {
                if (m.OriginalLabel == nLabel)
                {
                    if (!m.ConditionBoostEquals.HasValue)
                    {
                        return m.NewLabel;
                    }
                    else
                    {
                        if (m.ConditionBoostEquals == nBoost)
                            return m.NewLabel;
                        else if (m.NewLabelConditionFalse.HasValue)
                            return m.NewLabelConditionFalse.Value;
                    }
                }
            }
 
            return nLabel;
        }
 
        public int MapLabelWithoutBoost(int nLabel)
        {
            foreach (LabelMapping m in m_rgMappings)
            {
                if (m.OriginalLabel == nLabel )
                    return m.NewLabel;
            }
 
            return nLabel;
        }
 
        public IEnumerator<LabelMapping> GetEnumerator()
        {
            return m_rgMappings.GetEnumerator();
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return m_rgMappings.GetEnumerator();
        }
 
        public void Sort()
        {
            m_rgMappings.Sort(new Comparison<LabelMapping>(compare));
        }
 
        private int compare(LabelMapping a, LabelMapping b)
        {
            if (a.OriginalLabel < b.OriginalLabel)
                return -1;
 
            if (a.OriginalLabel > b.OriginalLabel)
                return 1;
 
            if (a.NewLabel < b.NewLabel)
                return -1;
 
            if (a.NewLabel > b.NewLabel)
                return 1;
 
            return 0;
        }
 
        public bool Compare(LabelMappingCollection col)
        {
            Sort();
            col.Sort();
 
            string strA = ToString();
            string strB = col.ToString();
 
            if (strA == strB)
                return true;
 
            return false;
        }
 
        public override string ToString()
        {
            List<string> rgstr = ToStringList();
            string str = "";
 
            foreach (string strMapping in rgstr)
            {
                str += strMapping;
                str += ";";
            }
 
            return str.TrimEnd(';');
        }
 
        public List<string> ToStringList()
        {
            List<string> rgstrMappings = new List<string>();
 
            foreach (LabelMapping map in m_rgMappings)
            {
                rgstrMappings.Add(map.ToString());
            }
 
            return rgstrMappings;
        }
 
        public static LabelMappingCollection Parse(string strMappings)
        {
            string[] rgstrMappings = strMappings.Split(';');
            return Parse(new List<string>(rgstrMappings));
        }
 
        public static LabelMappingCollection Parse(List<string> rgstrMappings)
        {
            LabelMappingCollection col = new LabelMappingCollection();
            List<string> rgstrSeparators = new List<string>() { "->" };
 
            foreach (string strMapping in rgstrMappings)
            {
                string[] rgstr = strMapping.Split(rgstrSeparators.ToArray(), StringSplitOptions.RemoveEmptyEntries);
 
                if (rgstr.Length != 2)
                    throw new Exception("Each label mapping should have the format 'original->new_label'.");
 
                if (rgstr[0].Length == 0 || rgstr[1].Length == 0)
                    throw new Exception("Each label mapping should have the format 'original->new_label'.");
 
                string str1 = rgstr[0].Trim('\"');
                string str2 = rgstr[1].Trim('\"');
                int? nConditionBoostEquals = null;
                int? nConditionFalse = null;
 
                rgstr = str2.Split('?');
                if (rgstr.Length > 1)
                {
                    str2 = rgstr[0].Trim();
 
                    string strCondition = "";
                    string strRightSide = rgstr[1].Trim();
                    rgstr = strRightSide.Split(',');
 
                    if (rgstr.Length == 2)
                    {
                        string str3 = rgstr[0].Trim();
                        if (str3.Length > 0)
                            nConditionFalse = int.Parse(str3);
 
                        strCondition = rgstr[1].Trim();
                    }
                    else if (rgstr.Length == 1)
                    {
                        strCondition = rgstr[0].Trim();
                    }
                    else
                    {
                        throw new Exception("Invalid mapping format! Expected format <true_int>?<false_int>,boost=<int>");
                    }
 
                    rgstr = strCondition.Split('=');
 
                    if (rgstr.Length != 2 || rgstr[0].Trim().ToLower() != "boost")
                        throw new Exception("Invalid boost condition!  Expected format = ?boost=<int>");
 
                    nConditionBoostEquals = int.Parse(rgstr[1].Trim());
                }
 
                col.Add(new LabelMapping(int.Parse(str1), int.Parse(str2), nConditionBoostEquals, nConditionFalse));
            }
 
            return col;
        }
    }
 
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class LabelMapping
    {
        int m_nOrignalLabel = 0;
        int m_nNewLabelConditionTrue = 0;
        int? m_nNewLabelConditionFalse = null;
        int? m_nConditionBoostEquals = null;
 
 
        public LabelMapping(int nOriginalLabel, int nNewLabel, int? nConditionBoostEquals, int? nNewLabelConditionFalse)
        {
            m_nOrignalLabel = nOriginalLabel;
            m_nNewLabelConditionTrue = nNewLabel;
            m_nNewLabelConditionFalse = nNewLabelConditionFalse;
            m_nConditionBoostEquals = nConditionBoostEquals;
        }
 
        public LabelMapping()
        {
        }
 
        [Description("Specifies the original label.")]
        public int OriginalLabel
        {
            get { return m_nOrignalLabel; }
            set { m_nOrignalLabel = value; }
        }
 
        [Description("Specifies the new label replacement.")]
        public int NewLabel
        {
            get { return m_nNewLabelConditionTrue; }
            set { m_nNewLabelConditionTrue = value; }
        }
 
        [Description("Specifies the label to use if the boost condition fails.")]
        public int? NewLabelConditionFalse
        {
            get { return m_nNewLabelConditionFalse; }
            set { m_nNewLabelConditionFalse = value; }
        }
 
        [Description("Specifies the boost condition to test.")]
        public int? ConditionBoostEquals
        {
            get { return m_nConditionBoostEquals; }
            set { m_nConditionBoostEquals = value; }
        }
 
        public LabelMapping Clone()
        {
            return new LabelMapping(m_nOrignalLabel, m_nNewLabelConditionTrue, m_nConditionBoostEquals, m_nNewLabelConditionFalse);
        }
 
        public static LabelMapping Parse(string str)
        {
            string strTarget = "->";
            int nPos = str.IndexOf(strTarget);
            if (nPos < 0)
                throw new Exception("Invalid label mapping format, missing '" + strTarget + "'!");
 
            string strLabelOriginal = str.Substring(0, nPos);
            str = str.Substring(nPos + strTarget.Length);
 
            string strCondition = null;
            string strNewLabelFalse = null;
            string strNewLabel = str;
            nPos = str.IndexOf('?');
            if (nPos > 0)
            {
                strNewLabel = str.Substring(0, nPos);
                str = str.Substring(nPos + 1);
 
                nPos = str.IndexOf(',');
                if (nPos > 0)
                {
                    strNewLabelFalse = str.Substring(0, nPos);
                    str = str.Substring(nPos + 1);
                }
 
                strTarget = "boost=";
                nPos = str.IndexOf(strTarget);
                if (nPos < 0)
                    throw new Exception("Invalid label mapping format, missing '" + strTarget + "'!");
 
                str = str.Substring(nPos + strTarget.Length);
                strCondition = str;
            }
 
            int nOriginalLabel = int.Parse(strLabelOriginal);
            int nNewLabel = int.Parse(strNewLabel);
            int? nNewLabelFalse = null;
            int? nCondition = null;
 
            if (strNewLabelFalse != null)
                nNewLabelFalse = int.Parse(strNewLabelFalse);
 
            if (strCondition != null)
                nCondition = int.Parse(strCondition);
 
            return new LabelMapping(nOriginalLabel, nNewLabel, nCondition, nNewLabelFalse);
        }
 
        public override string ToString()
        {
            string strMapping = m_nOrignalLabel.ToString() + "->" + m_nNewLabelConditionTrue.ToString();
 
            if (m_nConditionBoostEquals.HasValue)
            {
                strMapping += "?";
 
                if (m_nNewLabelConditionFalse.HasValue)
                {
                    strMapping += m_nNewLabelConditionFalse.Value.ToString();
                    strMapping += ",";
                }
 
                strMapping += "boost=";
                strMapping += m_nConditionBoostEquals.Value.ToString();
            }
 
            return strMapping;
        }
    }
}