DataNoiseParameter.cs

using MyCaffe.basecode;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class DataNoiseParameter
    {
        int m_nNoiseDataLabel = -1;
        bool m_bUseNoisyMean = true;
        string m_strNoisyDataSavePath = null;
        FillerParameter m_noiseFiller = new FillerParameter("constant", 1);
 
        public DataNoiseParameter()
        {
        }
 
        [Description("Specifies to multipy the noisy data by the mean to produce the final noisy data (default = true).  NOTE: When using this setting, the filler should be configured to produce values in the range [0,1].")]
        public bool use_noisy_mean
        {
            get { return m_bUseNoisyMean; }
            set { m_bUseNoisyMean = value; }
        }
 
        [Description("Specifies the label used with each noise filled data used when 'use_noise_for_match' = True (default = -1).")]
        public int noise_data_label
        {
            get { return m_nNoiseDataLabel; }
            set { m_nNoiseDataLabel = value; }
        }
 
        [Description("Specifies the noise filler used when 'use_noise_for_nonmatch' = True.  By default the 'noise_filler' is set to CONSTANT(1) which, when used with the 'use_noisy_mean' = True, uses the mean image as the data noise.")]
        public FillerParameter noise_filler
        {
            get { return m_noiseFiller; }
            set { m_noiseFiller = value; }
        }
 
        [Description("Optionally, specifies the path where the noisy data image is saved for debugging (default = null, which ignores this setting).")]
        public string noisy_save_path
        {
            get { return m_strNoisyDataSavePath; }
            set { m_strNoisyDataSavePath = value; }
        }
 
        private string noisy_save_path_persist
        {
            get
            {
                string strPath = Utility.Replace(m_strNoisyDataSavePath, ':', ';');
                return Utility.Replace(strPath, ' ', '~');
            }
 
            set
            {
                string strPath = Utility.Replace(value, ';', ':');
                m_strNoisyDataSavePath = Utility.Replace(strPath, '~', ' ');
            }
        }
 
        public void Copy(DataNoiseParameter pSrc)
        {
            if (pSrc == null)
                return;
 
            m_bUseNoisyMean = pSrc.m_bUseNoisyMean;
            m_nNoiseDataLabel = pSrc.m_nNoiseDataLabel;
            m_strNoisyDataSavePath = pSrc.m_strNoisyDataSavePath;
 
            if (pSrc.m_noiseFiller != null)
                m_noiseFiller = pSrc.m_noiseFiller.Clone();
        }
 
        public RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("use_noisy_mean", m_bUseNoisyMean.ToString());
            rgChildren.Add("noise_data_label", m_nNoiseDataLabel.ToString());
            rgChildren.Add("noisy_data_path", noisy_save_path_persist);
 
            if (noise_filler != null)
                rgChildren.Add(noise_filler.ToProto("noise_filler"));
 
            return new RawProto(strName, "", rgChildren);
        }
 
 
        public static DataNoiseParameter FromProto(RawProto rp, DataNoiseParameter p = null)
        {
            string strVal;
 
            if (p == null)
                p = new DataNoiseParameter();
 
            if ((strVal = rp.FindValue("use_noisy_mean")) != null)
                p.use_noisy_mean = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("noise_data_label")) != null)
                p.noise_data_label = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("noisy_data_path")) != null)
                p.noisy_save_path_persist = strVal;
 
            RawProto rpNoiseFiller = rp.FindChild("noise_filler");
            if (rpNoiseFiller != null)
                p.noise_filler = FillerParameter.FromProto(rpNoiseFiller);
 
            return p;
        }
    }
}