ResultDescriptor.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.basecode.descriptors
{
    [Serializable]
    public class ResultDescriptor : BaseDescriptor
    {
        int m_nIdx;
        int m_nLabel;
        int m_nSourceID;
        DateTime m_dt;
        List<KeyValuePair<int, double>> m_rgResults = new List<KeyValuePair<int, double>>();
 
        public ResultDescriptor(int nID, string strName, string strOwner, int nIdx, int nLabel, int nResultCount, byte[] rgResults, int nSrcId, DateTime dt)
            : base(nID, strName, strOwner)
        {
            m_nIdx = nIdx;
            m_nLabel = nLabel;
            m_nSourceID = nSrcId;
            m_dt = dt;
            m_rgResults = createResults(nResultCount, rgResults);
        }
 
        public int Index
        {
            get { return m_nIdx; }
        }
 
        public int Label
        {
            get { return m_nLabel; }
        }
 
        public int ResultCount
        {
            get { return m_rgResults.Count; }
        }
 
        public List<KeyValuePair<int, double>> Results
        {
            get { return m_rgResults; }
        }
 
        public int SourceID
        {
            get { return m_nSourceID; }
        }
 
        public DateTime TimeStamp
        {
            get { return m_dt; }
        }
 
        public static byte[] CreateResults(List<Result> rgResults, bool bInvert)
        {
            List<byte> rgData = new List<byte>();
            double dfMax = double.MinValue;
            double dfMin = double.MaxValue;
 
            if (bInvert)
            {
                foreach (Result kv in rgResults)
                {
                    if (dfMax < kv.Score)
                        dfMax = kv.Score;
 
                    if (dfMin > kv.Score)
                        dfMin = kv.Score;
                }
            }
 
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write(rgResults.Count);
 
                foreach (Result kv in rgResults)
                {
                    bw.Write(kv.Label);
 
                    double dfValue = kv.Score;
 
                    if (bInvert)
                        dfValue = dfMax - dfValue;
 
                    bw.Write(dfValue);
                }
 
                ms.Flush();
                return ms.ToArray();
            }
        }
 
        public static List<Result> GetResults(byte[] rgData)
        {
            List<Result> rgRes = new List<Result>();
 
            using (MemoryStream ms = new MemoryStream(rgData))
            using (BinaryReader br = new BinaryReader(ms))
            {
                return GetResults(br);
            }
        }
 
        public static List<Result> GetResults(BinaryReader br)
        {
            List<Result> rgRes = new List<Result>();
 
            int nCount = br.ReadInt32();
 
            for (int i = 0; i < nCount; i++)
            {
                int nLabel = br.ReadInt32();
                double dfVal = br.ReadDouble();
 
                Result r = new Result(nLabel, dfVal);
                rgRes.Add(r);
            }
 
            return rgRes;
        }
 
        public static byte[] CreateResults(List<Tuple<SimpleDatum, List<Result>>> rgrgResults)
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write(rgrgResults.Count);
 
                for (int i = 0; i < rgrgResults.Count; i++)
                {
                    bw.Write(rgrgResults[i].Item1.ImageID);
                    bw.Write(rgrgResults[i].Item1.Index);
                    bw.Write(rgrgResults[i].Item1.TimeStamp.ToFileTimeUtc());
                    bw.Write(CreateResults(rgrgResults[i].Item2, false));
                }
 
                ms.Flush();
                return ms.ToArray();
            }
        }
 
        public static List<Tuple<SimpleDatum, List<Result>>> GetResults(int nBatchCount, byte[] rgData)
        {
            if (nBatchCount <= 0)
                throw new Exception("The batch count must be >= 1!");
 
            List<Tuple<SimpleDatum, List<Result>>> rgRes1 = new List<Tuple<SimpleDatum, List<Result>>>();
 
            using (MemoryStream ms = new MemoryStream(rgData))
            using (BinaryReader br = new BinaryReader(ms))
            {
                int nCount = br.ReadInt32();
                if (nCount != nBatchCount)
                    throw new Exception("The batch count does not match the expected count of " + nCount.ToString());
 
                for (int i = 0; i < nCount; i++)
                {
                    int nImageID = br.ReadInt32();
                    int nIdx = br.ReadInt32();
                    long lTime = br.ReadInt64();
                    DateTime dt = DateTime.FromFileTimeUtc(lTime);
                    List<Result> rgRes = GetResults(br);
 
                    SimpleDatum sd = new SimpleDatum();
                    sd.SetImageID(nImageID);
                    sd.Index = nIdx;
                    sd.TimeStamp = dt;
 
                    rgRes1.Add(new Tuple<SimpleDatum, List<Result>>(sd, rgRes));
                }
            }
 
            return rgRes1;
        }
 
        private List<KeyValuePair<int, double>> createResults(int nCount, byte[] rgData)
        {
            List<KeyValuePair<int, double>> rgResults = new List<KeyValuePair<int, double>>();
            int nIdx = 0;
 
            for (int i = 0; i < nCount; i++)
            {
                int nVal = BitConverter.ToInt32(rgData, nIdx);
                nIdx += sizeof(int);
                double dfVal = BitConverter.ToDouble(rgData, nIdx);
                nIdx += sizeof(double);
 
                rgResults.Add(new KeyValuePair<int, double>(nVal, dfVal));
            }
 
            return rgResults;
        }
 
        public override string ToString()
        {
            return m_dt.ToString() + " ~ " + m_nLabel.ToString();
        }
    }
}