DatasetDescriptor.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.basecode.descriptors
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class DatasetDescriptor : BaseDescriptor
    {
        SourceDescriptor m_srcTest;
        SourceDescriptor m_srcTrain;
        GroupDescriptor m_groupDataset;
        GroupDescriptor m_groupModel;
        ParameterDescriptorCollection m_colParameters = new ParameterDescriptorCollection();
        string m_strCreatorName;
        string m_strDescription;
        GYM_TYPE m_gymType = GYM_TYPE.NONE;
 
        public DatasetDescriptor(int nID, string strName, GroupDescriptor grpModel, GroupDescriptor grpDs, SourceDescriptor srcTrain, SourceDescriptor srcTest, string strCreatorName, string strDescription, string strOwner = null, GYM_TYPE gymType = GYM_TYPE.NONE)
            : base(nID, strName, strOwner)
        {
            m_gymType = gymType;
 
            if (grpModel != null)
                m_groupModel = new descriptors.GroupDescriptor(grpModel);
            else
                m_groupModel = new descriptors.GroupDescriptor(0, null, null);
 
            if (grpDs != null)
                m_groupDataset = new descriptors.GroupDescriptor(grpDs);
            else
                m_groupDataset = new descriptors.GroupDescriptor(0, null, null);
 
            if (srcTest != null)
                m_srcTest = new SourceDescriptor(srcTest);
 
            if (srcTrain != null)
                m_srcTrain = new SourceDescriptor(srcTrain);
 
            m_strDescription = strDescription;
            m_strCreatorName = strCreatorName;
        }
 
        public DatasetDescriptor(string strName)
            : this(0, strName, null, null, null, null, null, "")
        {
        }
 
        public DatasetDescriptor(DatasetDescriptor d)
            : this(d.ID, d.Name, d.ModelGroup, d.DatasetGroup, d.TrainingSource, d.TestingSource, d.CreatorName, d.Description, d.Owner, d.GymType)
        {
            m_colParameters = new ParameterDescriptorCollection(d.Parameters);
        }
 
        public void Resize(int nChannels, int nHeight, int nWidth)
        {
            m_srcTest.Resize(nChannels, nHeight, nWidth);
            m_srcTrain.Resize(nChannels, nHeight, nWidth);
        }
 
        public void Copy(DatasetDescriptor ds)
        {
            base.Copy(ds);
 
            m_gymType = ds.m_gymType;
 
            if (ds.m_srcTest != null)
                m_srcTest = new SourceDescriptor(ds.m_srcTest);
            else
                m_srcTest = null;
 
            if (ds.m_srcTrain != null)
                m_srcTrain = new SourceDescriptor(ds.m_srcTrain);
            else
                m_srcTrain = null;
 
            if (ds.m_groupDataset != null)
                m_groupDataset = new GroupDescriptor(ds.m_groupDataset);
            else
                m_groupDataset = null;
 
            if (ds.m_groupModel != null)
                m_groupModel = new GroupDescriptor(ds.m_groupModel);
            else
                m_groupModel = null;
 
            m_colParameters = new descriptors.ParameterDescriptorCollection();
            foreach (ParameterDescriptor p in ds.m_colParameters)
            {
                m_colParameters.Add(new ParameterDescriptor(p));
            }
 
            m_strCreatorName = ds.m_strCreatorName;
            m_strDescription = ds.m_strDescription;
        }
 
        public bool IsGym
        {
            get { return (m_gymType == GYM_TYPE.NONE) ? false : true; }
        }
 
        public GYM_TYPE GymType
        {
            get { return m_gymType; }
        }
 
        public bool IsModelData
        {
            get { return Name.StartsWith("MODEL") ? true : false; }
        }
 
        public bool IsDataTemporal
        {
            get { return IsModelData && Name.Contains("TEMPORAL") || (TrainingSource != null && TrainingSource.TemporalDescriptor != null); }
        }
 
        public string FullName
        {
            get { return (IsGym) ? "GYM:" + Name : Name; }
        }
 
        public static bool IsGymName(string str)
        {
            if (str.IndexOf("GYM:") == 0)
                return true;
 
            return false;
        }
 
        public static bool IsModelDataName(string str, out bool bTemporal)
        {
            bTemporal = false;
 
            if (str.StartsWith("MODEL"))
            {
                if (str.Contains(":TEMPORAL"))
                    bTemporal = true;
                return true;
            }
 
            return false;
        }
 
        public static string GetGymName(string str, out string strType)
        {
            strType = null;
 
            int nPos = str.IndexOf("GYM:");
            if (nPos < 0)
                return str;
 
            str = str.Substring(4);
 
            nPos = str.IndexOf(':');
            if (nPos < 0)
                return str;
 
            strType = str.Substring(nPos + 1);
            return str.Substring(0, nPos);
        }
 
        [Category("Groups"), Description("Specifies the dataset group (if any).")]
        public GroupDescriptor DatasetGroup
        {
            get { return m_groupDataset; }
        }
 
        [Category("Groups"), Description("Specifies the model group (if any).")]
        public GroupDescriptor ModelGroup
        {
            get { return m_groupModel; }
            set { m_groupModel = value; }
        }
 
        [Category("Sources"), Description("Specifies the data source used when training.")]
        public SourceDescriptor TrainingSource
        {
            get { return m_srcTrain; }
            set { m_srcTrain = value; }
        }
 
        [Category("Sources"), Description("Specifies the data source used when testing.")]
        public SourceDescriptor TestingSource
        {
            get { return m_srcTest; }
            set { m_srcTest = value; }
        }
 
        [Browsable(false)]
        public string TrainingSourceName
        {
            get { return (m_srcTrain == null) ? null : m_srcTrain.Name; }
        }
 
        [Browsable(false)]
        public string TestingSourceName
        {
            get { return (m_srcTest == null) ? null : m_srcTest.Name; }
        }
 
        [Description("Specifies the name of the creator used to create this dataset.")]
        public string CreatorName
        {
            get { return m_strCreatorName; }
        }
 
        [Description("Specifies the description of this dataset.")]
        public string Description
        {
            get { return m_strDescription; }
            set { m_strDescription = value; }
        }
 
        [Description("Specifies the parameters of the data set (if any).")]
        public ParameterDescriptorCollection Parameters
        {
            get { return m_colParameters; }
            set { m_colParameters = value; }
        }
 
        public static byte[] Serialize(DatasetDescriptor ds)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(ms, ds);
                ms.Flush();
                return ms.ToArray();
            }
        }
 
        public static DatasetDescriptor Deserialize(byte[] rg)
        {
            using (MemoryStream ms = new MemoryStream(rg))
            {
                BinaryFormatter bf = new BinaryFormatter();
                return bf.Deserialize(ms) as DatasetDescriptor;
            }
        }
 
        public override string ToString()
        {
            return m_strCreatorName + ":" + Name;
        }
    }
}