PriorBoxParameter.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 PriorBoxParameter : LayerParameterBase
    {
        List<float> m_rgMinSize = new List<float>();
        List<float> m_rgMaxSize = new List<float>();
        List<float> m_rgAspectRatio = new List<float>();
        bool m_bFlip = true;
        bool m_bClip = false;
        List<float> m_rgVariance = new List<float>();
        uint? m_nImgSize = null;
        uint? m_nImgH = null;
        uint? m_nImgW = null;
        float? m_fStep = null;
        float? m_fStepH = null;
        float? m_fStepW = null;
        float m_fOffset = 0.5f;
 
        public enum CodeType
        {
            CORNER = 1,
            CENTER_SIZE = 2,
            CORNER_SIZE = 3
        }
 
        public static CodeType CodeTypeFromString(string str)
        {
            switch (str)
            {
                case "CORNER":
                    return CodeType.CORNER;
 
                case "CENTER_SIZE":
                    return CodeType.CENTER_SIZE;
 
                case "CORNER_SIZE":
                    return CodeType.CORNER_SIZE;
 
                default:
                    throw new Exception("Unknown CodeType '" + str + "'!");
            }
        }
 
        public PriorBoxParameter()
        {
        }
 
        [Description("Specifies the minimum box size (in pixels) and is required!")]
        public List<float> min_size
        {
            get { return m_rgMinSize; }
            set { m_rgMinSize = value; }
        }
 
        [Description("Specifies the maximum box size (in pixels) and is required!")]
        public List<float> max_size
        {
            get { return m_rgMaxSize; }
            set { m_rgMaxSize = value; }
        }
 
        [Description("Specifies various aspect ratios.  Duplicate ratios are ignored. If none are provided, a default ratio of 1 is used.")]
        public List<float> aspect_ratio
        {
            get { return m_rgAspectRatio; }
            set { m_rgAspectRatio = value; }
        }
 
        [Description("Specifies whether or not to flip each aspect ratio. For example, if there is an aspect ratio 'r' we will generate aspect ratio '1.0/r' as well.")]
        public bool flip
        {
            get { return m_bFlip; }
            set { m_bFlip = value; }
        }
 
        [Description("Specifies whether or not to clip the prior so that it is within [0,1].")]
        public bool clip
        {
            get { return m_bClip; }
            set { m_bClip = value; }
        }
 
        [Description("Specifies the variance for adjusting the prior boxes.")]
        public List<float> variance
        {
            get { return m_rgVariance; }
            set { m_rgVariance = value; }
        }
 
        [Description("Specifies the image size.  By default we calculate the img_height, img_width, step_x and step_y based on bottom[0] (feat) and bottom[1] (img).  Unless these values are explicitly provided here. Either the img_h and img_w are used or the img_size, but not both.")]
        public uint? img_size
        {
            get { return m_nImgSize; }
            set { m_nImgSize = value; }
        }
 
        [Description("Specifies the image height.  By default we calculate the img_height, img_width, step_x and step_y based on bottom[0] (feat) and bottom[1] (img).  Unless these values are explicitly provided here. Either the img_h and img_w are used or the img_size, but not both.")]
        public uint? img_h
        {
            get { return m_nImgH; }
            set { m_nImgH = value; }
        }
 
        [Description("Specifies the image width.  By default we calculatethe img_height, img_width, step_x and step_y based on bottom[0] (feat) and bottom[1] (img).  Unless these values are explicitly provided here. Either the img_h and img_w are used or the img_size, but not both.")]
        public uint? img_w
        {
            get { return m_nImgW; }
            set { m_nImgW = value; }
        }
 
        [Description("Specifies the excplicit step size to use.")]
        public float? step
        {
            get { return m_fStep; }
            set { m_fStep = value; }
        }
 
        [Description("Specifies the explicit step size to use along height. Either the step_h and step_w are used or the step, but not both.")]
        public float? step_h
        {
            get { return m_fStepH; }
            set { m_fStepH = value; }
        }
 
        [Description("Specifies the explicit step size to use along width. Either the step_h and step_w are used or the step, but not both.")]
        public float? step_w
        {
            get { return m_fStepW; }
            set { m_fStepW = value; }
        }
 
        [Description("Specifies the offset to the top left corner of each cell.")]
        public float offset
        {
            get { return m_fOffset; }
            set { m_fOffset = value; }
        }
 
        public override object Load(BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            PriorBoxParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            PriorBoxParameter p = src as PriorBoxParameter;
 
            m_rgMinSize = Utility.Clone<float>(p.min_size);
            m_rgMaxSize = Utility.Clone<float>(p.max_size);
            m_rgAspectRatio = Utility.Clone<float>(p.aspect_ratio);
            m_bFlip = p.flip;
            m_bClip = p.clip;
            m_rgVariance = Utility.Clone<float>(p.variance);
            m_nImgSize = p.img_size;
            m_nImgH = p.img_h;
            m_nImgW = p.img_w;
            m_fStep = p.step;
            m_fStepH = p.step_h;
            m_fStepW = p.step_w;
            m_fOffset = p.offset;
        }
 
        public override LayerParameterBase Clone()
        {
            PriorBoxParameter p = new param.ssd.PriorBoxParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add<float>("min_size", min_size);
            rgChildren.Add<float>("max_size", max_size);
            rgChildren.Add<float>("aspect_ratio", aspect_ratio);
            rgChildren.Add("flip", flip.ToString());
            rgChildren.Add("clip", clip.ToString());
            rgChildren.Add<float>("variance", variance);
 
            if (img_size.HasValue)
            {
                rgChildren.Add("img_size", img_size.Value.ToString());
            }
            else
            {
                if (img_h.HasValue)
                    rgChildren.Add("img_h", img_h.Value.ToString());
                if (img_w.HasValue)
                    rgChildren.Add("img_w", img_w.Value.ToString());
            }
 
            if (step.HasValue)
            {
                rgChildren.Add("step", step.Value.ToString());
            }
            else
            {
                if (step_h.HasValue)
                    rgChildren.Add("step_h", step_h.Value.ToString());
                if (step_w.HasValue)
                    rgChildren.Add("step_w", step_w.Value.ToString());
            }
 
            rgChildren.Add("offset", offset.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
 
 
        public static PriorBoxParameter FromProto(RawProto rp)
        {
            PriorBoxParameter p = new PriorBoxParameter();
            string strVal;
 
            p.min_size = rp.FindArray<float>("min_size");
            p.max_size = rp.FindArray<float>("max_size");
            p.aspect_ratio = rp.FindArray<float>("aspect_ratio");
 
            if ((strVal = rp.FindValue("flip")) != null)
                p.flip = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("clip")) != null)
                p.clip = bool.Parse(strVal);
 
            p.variance = rp.FindArray<float>("variance");
 
            if ((strVal = rp.FindValue("img_size")) != null)
            {
                p.img_size = uint.Parse(strVal);
            }
            else
            {
                if ((strVal = rp.FindValue("img_h")) != null)
                    p.img_h = uint.Parse(strVal);
 
                if ((strVal = rp.FindValue("img_w")) != null)
                    p.img_w = uint.Parse(strVal);
            }
 
            if ((strVal = rp.FindValue("step")) != null)
            {
                p.step = ParseFloat(strVal);
            }
            else
            {
                if ((strVal = rp.FindValue("step_h")) != null)
                    p.step_h = ParseFloat(strVal);
 
                if ((strVal = rp.FindValue("step_w")) != null)
                    p.step_w = ParseFloat(strVal);
            }
 
            if ((strVal = rp.FindValue("offset")) != null)
                p.offset = ParseFloat(strVal);
 
            return p;
        }
 
        public static List<float> GetAspectRatios(PriorBoxParameter p)
        {
            List<float> rgAspectRatios = new List<float>();
 
            rgAspectRatios.Add(1.0f);
 
            for (int i = 0; i < p.aspect_ratio.Count; i++)
            {
                float fAr = p.aspect_ratio[i];
                bool bAlreadyExists = false;
 
                for (int j = 0; j < rgAspectRatios.Count; j++)
                {
                    if (Math.Abs(fAr - rgAspectRatios[j]) < 1e-6f)
                    {
                        bAlreadyExists = true;
                        break;
                    }
                }
 
                if (!bAlreadyExists)
                {
                    rgAspectRatios.Add(fAr);
                    if (p.flip)
                        rgAspectRatios.Add(1.0f / fAr);
                }
            }
 
            return rgAspectRatios;
        }
 
        public static List<int> Reshape(PriorBoxParameter p, int nLayerWid, int nLayerHt, int? nNumPriors = null)
        {
            List<int> rgTopShape = Utility.Create<int>(3, 1);
            if (!nNumPriors.HasValue)
            {
                int nMinCount = (p.min_size == null) ? 0 : p.min_size.Count;
                List<float> rgAspectRatios = GetAspectRatios(p);
                int nAspectCount = rgAspectRatios.Count;
 
                nNumPriors = nMinCount * nAspectCount;
 
                if (p.max_size != null)
                    nNumPriors += p.max_size.Count;
            }
 
            // Since all images in a batch have the same height and width, we only need to
            // generate one set of priors which can be shared across all images.
            rgTopShape[0] = 1;
 
            // 2 channels. 
            // First channel stores the mean of each prior coordinate.
            // Second channel stores the variance of each prior coordiante.
            rgTopShape[1] = 2;
            rgTopShape[2] = nLayerWid * nLayerHt * nNumPriors.Value * 4;
 
            return rgTopShape;
        }
    }
}