DistortionParameter.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MyCaffe.basecode;
 
namespace MyCaffe.param.ssd
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class DistortionParameter : OptionalParameter
    {
        float m_fBrightnessProb = 0;
        float m_fBrightnessDelta = 0.0f;
 
        float m_fContrastProb = 0;
        float m_fContrastLower = 0.5f;
        float m_fContrastUpper = 1.5f;
 
        float m_fSaturationProb = 0;
        float m_fSaturationLower = 0.5f;
        float m_fSaturationUpper = 1.5f;
 
        float m_fRandomOrderProb = 0;
 
        long m_lRandomSeed = 0;
        bool m_bUseGpu = true;
 
        public DistortionParameter(bool bActive) : base(bActive)
        {
        }
 
        public long random_seed
        {
            get { return m_lRandomSeed; }
            set { m_lRandomSeed = value; }
        }
 
        public bool use_gpu
        {
            get { return m_bUseGpu; }
            set { m_bUseGpu = value; }
        }
 
        [Description("Get/set probability of adjusting the brightness.")]
        public float brightness_prob
        {
            get { return m_fBrightnessProb; }
            set { m_fBrightnessProb = value; }
        }
 
        [Description("Get/set amount to add to the pixel values within [-delta,delta]")]
        public float brightness_delta
        {
            get { return m_fBrightnessDelta; }
            set { m_fBrightnessDelta = value; }
        }
 
        [Description("Get/set probability of adjusting the contrast.")]
        public float contrast_prob
        {
            get { return m_fContrastProb; }
            set { m_fContrastProb = value; }
        }
 
        [Description("Get/set lower bound for random contrast factor.")]
        public float contrast_lower
        {
            get { return m_fContrastLower; }
            set { m_fContrastLower = value; }
        }
 
        [Description("Get/set upper bound for random contrast factor.")]
        public float contrast_upper
        {
            get { return m_fContrastUpper; }
            set { m_fContrastUpper = value; }
        }
 
        [Description("Get/set probability of adjusting the saturation.")]
        public float saturation_prob
        {
            get { return m_fSaturationProb; }
            set { m_fSaturationProb = value; }
        }
 
        [Description("Get/set lower bound for random saturation factor.")]
        public float saturation_lower
        {
            get { return m_fSaturationLower; }
            set { m_fSaturationLower = value; }
        }
 
        [Description("Get/set upper bound for random saturation factor.")]
        public float saturation_upper
        {
            get { return m_fSaturationUpper; }
            set { m_fSaturationUpper = value; }
        }
 
        [Description("Get/set the probability of randomly ordering the image channels.")]
        public float random_order_prob
        {
            get { return m_fRandomOrderProb; }
            set { m_fRandomOrderProb = value; }
        }
 
        public override void Copy(OptionalParameter src)
        {
            base.Copy(src);
 
            if (src is DistortionParameter)
            {
                DistortionParameter p = (DistortionParameter)src;
                m_fBrightnessProb = p.brightness_prob;
                m_fBrightnessDelta = p.brightness_delta;
 
                m_fContrastProb = p.contrast_prob;
                m_fContrastLower = p.contrast_lower;
                m_fContrastUpper = p.contrast_upper;
 
                m_fSaturationProb = p.saturation_prob;
                m_fSaturationLower = p.saturation_lower;
                m_fSaturationUpper = p.saturation_upper;
 
                m_fRandomOrderProb = p.random_order_prob;
 
                m_lRandomSeed = p.m_lRandomSeed;
                m_bUseGpu = p.use_gpu;
            }
        }
 
        public DistortionParameter Clone()
        {
            DistortionParameter p = new param.ssd.DistortionParameter(Active);
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProto rpBase = base.ToProto("option");
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(rpBase);
            rgChildren.Add(new RawProto("active", Active.ToString()));
            rgChildren.Add(new RawProto("brightness_prob", brightness_prob.ToString()));
            rgChildren.Add(new RawProto("brightness_delta", brightness_delta.ToString()));
            rgChildren.Add(new RawProto("contrast_prob", contrast_prob.ToString()));
            rgChildren.Add(new RawProto("contrast_lower", contrast_lower.ToString()));
            rgChildren.Add(new RawProto("contrast_upper", contrast_upper.ToString()));
            rgChildren.Add(new RawProto("saturation_prob", saturation_prob.ToString()));
            rgChildren.Add(new RawProto("saturation_lower", saturation_lower.ToString()));
            rgChildren.Add(new RawProto("saturation_upper", saturation_upper.ToString()));
            rgChildren.Add(new RawProto("random_order_prob", random_order_prob.ToString()));
            rgChildren.Add(new RawProto("use_gpu", use_gpu.ToString()));
            rgChildren.Add(new RawProto("random_seed", random_seed.ToString()));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new DistortionParameter FromProto(RawProto rp)
        {
            DistortionParameter p = new DistortionParameter(false);
            string strVal;
 
            RawProto rpOption = rp.FindChild("option");
            if (rpOption != null)
                ((OptionalParameter)p).Copy(OptionalParameter.FromProto(rpOption));
 
            if ((strVal = rp.FindValue("active")) != null)
                p.Active = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("brightness_prob")) != null)
                p.brightness_prob = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("brightness_delta")) != null)
                p.brightness_delta = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("contrast_prob")) != null)
                p.contrast_prob = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("contrast_lower")) != null)
                p.contrast_lower = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("contrast_upper")) != null)
                p.contrast_upper = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("saturation_prob")) != null)
                p.saturation_prob = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("saturation_lower")) != null)
                p.saturation_lower = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("saturation_upper")) != null)
                p.saturation_upper = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("random_order_prob")) != null)
                p.random_order_prob = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("use_gpu")) != null)
                p.use_gpu = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("random_seed")) != null)
                p.random_seed = long.Parse(strVal);
 
            return p;
        }
    }
}