ResultCollection.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using MyCaffe.db.image;
using MyCaffe.param;
 
namespace MyCaffe.common
{
    public class ResultCollection
    {
        Dictionary<int, string> m_rgLabels = new Dictionary<int, string>();
        List<Result> m_rgResultsOriginal = new List<Result>();
        List<Result> m_rgResultsSorted = new List<Result>();
        RESULT_TYPE m_resultType = RESULT_TYPE.NONE;
 
        public enum RESULT_TYPE
        {
            NONE,
            PROBABILITIES,
            DISTANCES,
            MULTIBOX,
            TEMPORAL
        }
 
        public ResultCollection(List<Result> rgResults, LayerParameter.LayerType outputLayerType)
        {
            m_resultType = GetResultType(outputLayerType);
            m_rgResultsOriginal = rgResults;
 
            foreach (Result item in rgResults)
            {
                m_rgResultsSorted.Add(item);
            }
 
            m_rgResultsSorted = m_rgResultsSorted.OrderByDescending(p => p.Score).ToList();
        }
 
        public static RESULT_TYPE GetResultType(LayerParameter.LayerType type)
        {
            switch (type)
            {
                case LayerParameter.LayerType.SOFTMAX:
                    return RESULT_TYPE.PROBABILITIES;
 
                case LayerParameter.LayerType.DECODE:
                    return RESULT_TYPE.DISTANCES;
 
                case LayerParameter.LayerType.DETECTION_OUTPUT:
                    return RESULT_TYPE.MULTIBOX;
 
                default:
                    return RESULT_TYPE.NONE;
            }
        }
 
        public RESULT_TYPE ResultType
        {
            get { return m_resultType; }
        }
 
        public List<double> GetEncoding()
        {
            List<double> rg = new List<double>();
 
            foreach (Result item in m_rgResultsOriginal)
            {
                rg.Add(item.Score);
            }
 
            return rg;
        }
 
        public List<Result> ResultsOriginal
        {
            get { return m_rgResultsOriginal; }
        }
 
        public List<Result> ResultsSorted
        {
            get { return m_rgResultsSorted; }
        }
 
        public int DetectedLabelMaxSignal
        {
            get { return m_rgResultsSorted[0].Label; }
        }
 
        public double DetectedLabelOutputMaxSignal
        {
            get { return m_rgResultsSorted[0].Score; }
        }
 
        public int DetectedLabelMinSignal
        {
            get { return m_rgResultsSorted[m_rgResultsSorted.Count-1].Label; }
        }
 
        public double DetectedLabelOutputMinSignal
        {
            get { return m_rgResultsSorted[m_rgResultsSorted.Count-1].Score; }
        }
 
        public int DetectedLabel
        {
            get
            {
                if (m_resultType == RESULT_TYPE.DISTANCES)
                    return DetectedLabelMinSignal;
                else
                    return DetectedLabelMaxSignal;
            }
        }
 
        public double DetectedLabelOutput
        {
            get
            {
                if (m_resultType == RESULT_TYPE.DISTANCES)
                    return DetectedLabelOutputMinSignal;
                else
                    return DetectedLabelOutputMaxSignal;
            }
        }
 
        public Dictionary<int, string> Labels
        {
            get { return m_rgLabels; }
        }
 
        public void SetLabels(List<LabelDescriptor> rgLabels)
        {
            m_rgLabels = new Dictionary<int, string>();
 
            foreach (LabelDescriptor l in rgLabels)
            {
                if (!m_rgLabels.ContainsKey(l.Label))
                    m_rgLabels.Add(l.Label, l.Name);
            }
        }
 
        public override string ToString()
        {
            string strOut = "";
 
            for (int i = 0; i < m_rgResultsOriginal.Count; i++)
            {
                int nLabel = m_rgResultsOriginal[i].Label;
                double dfVal = m_rgResultsOriginal[i].Score;
                string strName = null;
 
                if (m_rgLabels.ContainsKey(nLabel))
                    strName = m_rgLabels[nLabel];
 
                if (nLabel == DetectedLabelMaxSignal)
                    strOut += "[";
 
                if (strName != null)
                    strOut += strName;
                else
                    strOut += nLabel.ToString();
 
                strOut += "->";
                strOut += dfVal.ToString("N4");
 
                if (nLabel == DetectedLabelMaxSignal)
                    strOut += "]";
 
                if (i < m_rgResultsOriginal.Count - 1)
                    strOut += ", ";
            }
 
            return strOut;
        }
 
        public Image ToImage(ColorMapper clrMap)
        {
            int nW = (int)Math.Ceiling(Math.Sqrt(m_rgResultsOriginal.Count));
            int nH = nW;
            Size sz = new Size(nW, nH);
            return ImageData.GetImage(m_rgResultsOriginal, sz, clrMap);
        }
    }
}