NormalizedBBox.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.basecode
{
    [Serializable]
    public class NormalizedBBox
    {
        float m_fxmin = 0;  // [0]
        float m_fymin = 0;  // [1]
        float m_fxmax = 0;  // [2]
        float m_fymax = 0;  // [3]
        int m_nLabel = -1;
        bool m_bDifficult = false;
        float m_fScore = 0;
        float m_fSize = 0;
 
        public NormalizedBBox(float fxmin, float fymin, float fxmax, float fymax, int nLabel = 0, bool bDifficult = false, float fScore = 0, float fSize = 0)
        {
            Set(fxmin, fymin, fxmax, fymax, nLabel, bDifficult, fScore, fSize);
        }
 
        public void Set(float fxmin, float fymin, float fxmax, float fymax, int? nLabel = null, bool? bDifficult = null, float? fScore = null, float? fSize = null)
        {
            m_fxmin = fxmin;
            m_fxmax = fxmax;
            m_fymin = fymin;
            m_fymax = fymax;
 
            if (nLabel.HasValue)
                m_nLabel = nLabel.Value;
 
            if (bDifficult.HasValue)
                m_bDifficult = bDifficult.Value;
 
            if (fScore.HasValue)
                m_fScore = fScore.Value;
 
            if (fSize.HasValue)
                m_fSize = fSize.Value;
        }
 
        public NormalizedBBox Clone()
        {
            return new NormalizedBBox(m_fxmin, m_fymin, m_fxmax, m_fymax, m_nLabel, m_bDifficult, m_fScore, m_fSize);
        }
 
        public float xmin
        {
            get { return m_fxmin; }
            set { m_fxmin = value; }
        }
 
        public float xmax
        {
            get { return m_fxmax; }
            set { m_fxmax = value; }
        }
 
        public float ymin
        {
            get { return m_fymin; }
            set { m_fymin = value; }
        }
 
        public float ymax
        {
            get { return m_fymax; }
            set { m_fymax = value; }
        }
 
        public int label
        {
            get { return m_nLabel; }
            set { m_nLabel = value; }
        }
 
        public bool difficult
        {
            get { return m_bDifficult; }
            set { m_bDifficult = value; }
        }
 
        public float score
        {
            get { return m_fScore; }
            set { m_fScore = value; }
        }
 
        public float size
        {
            get { return m_fSize; }
            set { m_fSize = value; }
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write(m_fxmin);
            bw.Write(m_fxmax);
            bw.Write(m_fymin);
            bw.Write(m_fymax);
            bw.Write(m_nLabel);
            bw.Write(m_bDifficult);
            bw.Write(m_fScore);
            bw.Write(m_fSize);
        }
 
        public static NormalizedBBox Load(BinaryReader br)
        {
            float fXmin = br.ReadSingle();
            float fXmax = br.ReadSingle();
            float fYmin = br.ReadSingle();
            float fYmax = br.ReadSingle();
            int nLabel = br.ReadInt32();
            bool bDifficult = br.ReadBoolean();
            float fScore = br.ReadSingle();
            float fSize = br.ReadSingle();
 
            return new NormalizedBBox(fXmin, fYmin, fXmax, fYmax, nLabel, bDifficult, fScore, fSize);
        }
 
        public override string ToString()
        {
            string strOut = "(" + m_nLabel.ToString() + ") { ";
 
            strOut += m_fxmin.ToString() + ", ";
            strOut += m_fymin.ToString() + ", ";
            strOut += m_fxmax.ToString() + ", ";
            strOut += m_fymax.ToString() + " } -> ";
            strOut += m_fScore.ToString();
            strOut += " size = " + m_fSize.ToString();
            strOut += " difficult = " + m_bDifficult.ToString();
 
            return strOut;
        }
 
        public RectangleF GetBounds(int nWidth, int nHeight)
        {
            float fX1 = m_fxmin * nWidth;
            float fX2 = m_fxmax * nWidth;
            float fY1 = m_fymin * nHeight;
            float fY2 = m_fymax * nHeight;
 
            return new RectangleF(fX1, fY1, fX2 - fX1, fY2 - fY1);
        }
    }
}