Annotation.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
 
namespace MyCaffe.basecode
{
    [Serializable]
    public class Annotation
    {
        int m_nInstanceId = 0;
        NormalizedBBox m_bbox;
 
        public Annotation(NormalizedBBox bbox, int nInstanceId = 0)
        {
            m_bbox = bbox;
            m_nInstanceId = nInstanceId;
        }
 
        public Annotation Clone()
        {
            NormalizedBBox bbox = null;
 
            if (m_bbox != null)
                bbox = m_bbox.Clone();
 
            return new Annotation(bbox, m_nInstanceId);
        }
 
        public int instance_id
        {
            get { return m_nInstanceId; }
            set { m_nInstanceId = value; }
        }
 
        public NormalizedBBox bbox
        {
            get { return m_bbox; }
            set { m_bbox = value; }
        }
 
        public void Normalize(Rectangle rc)
        {
            float fxmin = 0;
            float fymin = 0;
            float fxmax = 1;
            float fymax = 1;
 
            if (m_bbox.xmin > rc.Left)
                fxmin = (m_bbox.xmin - rc.Left) / rc.Width;
 
            if (m_bbox.ymin > rc.Top)
                fymin = (m_bbox.ymin - rc.Top) / rc.Height;
 
            if (m_bbox.xmax < rc.Right)
                fxmax = (m_bbox.xmax - rc.Left) / rc.Width;
 
            if (m_bbox.ymax < rc.Bottom)
                fymax = (m_bbox.ymax - rc.Top) / rc.Height;
 
            m_bbox.Set(fxmin, fymin, fxmax, fymax);
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write(m_nInstanceId);
            m_bbox.Save(bw);
        }
 
        public static Annotation Load(BinaryReader br)
        {
            int nInstanceId = br.ReadInt32();
            NormalizedBBox bbox = NormalizedBBox.Load(br);
 
            return new Annotation(bbox, nInstanceId);
        }
    }
 
    [Serializable]
    public class AnnotationGroup
    {
        int m_nGroupLabel = 0;
        List<Annotation> m_rgAnnotations = new List<Annotation>();
 
        public AnnotationGroup(List<Annotation> rgAnnotations = null, int nGroupLabel = 0)
        {
            if (rgAnnotations != null && rgAnnotations.Count > 0)
                m_rgAnnotations.AddRange(rgAnnotations);
 
            m_nGroupLabel = nGroupLabel;
        }
 
        public AnnotationGroup Clone()
        {
            List<Annotation> rg = null;
 
            if (m_rgAnnotations != null)
            {
                rg = new List<Annotation>();
 
                foreach (Annotation a in m_rgAnnotations)
                {
                    rg.Add(a.Clone());
                }
            }
 
            return new AnnotationGroup(rg, m_nGroupLabel);
        }
 
        public Annotation GetMaxScoringAnnotation()
        {
            float fMaxScore = 0;
            int nMaxIdx = -1;
 
            for (int i = 0; i < m_rgAnnotations.Count; i++)
            {
                if (m_rgAnnotations[i].bbox.score >= fMaxScore)
                {
                    nMaxIdx = i;
                    fMaxScore = m_rgAnnotations[i].bbox.score;
                }
            }
 
            if (nMaxIdx < 0)
                return null;
 
            return m_rgAnnotations[nMaxIdx];
        }
 
        public void Normalize(Rectangle rc)
        {
            foreach (Annotation a in m_rgAnnotations)
            {
                a.Normalize(rc);
            }
        }
 
        public List<Annotation> annotations
        {
            get { return m_rgAnnotations; }
            set { m_rgAnnotations = value; }
        }
 
        public int group_label
        {
            get { return m_nGroupLabel; }
            set { m_nGroupLabel = value; }
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write(m_nGroupLabel);
            bw.Write(m_rgAnnotations.Count);
 
            for (int i = 0; i < m_rgAnnotations.Count; i++)
            {
                m_rgAnnotations[i].Save(bw);
            }
        }
 
        public static AnnotationGroup Load(BinaryReader br)
        {
            int nGroupLabel = br.ReadInt32();
            int nCount = br.ReadInt32();
            List<Annotation> rgAnnotations = new List<Annotation>();
 
            for (int i = 0; i < nCount; i++)
            {
                rgAnnotations.Add(Annotation.Load(br));
            }
 
            return new AnnotationGroup(rgAnnotations, nGroupLabel);
        }
    }
 
    [Serializable]
    public class AnnotationGroupCollection : IEnumerable<AnnotationGroup>
    {
        List<AnnotationGroup> m_rgItems = new List<AnnotationGroup>();
        Dictionary<int, string> m_rgLabels = new Dictionary<int, string>();
        int m_nImageID = 0;
        int m_nImageIdx = 0;
        int m_nCreatorID = 0;
        int m_nDatasetID = 0;
        int m_nSourceID = 0;
        bool m_bHasDataCriteria = false;
        bool m_bHasDebugData = false;
 
        public AnnotationGroupCollection()
        {
        }
 
        public bool HasDataCriteria
        {
            get { return m_bHasDataCriteria; }
            set { m_bHasDataCriteria = value; }
        }
 
        public bool HasDebugData
        {
            get { return m_bHasDebugData; }
            set { m_bHasDebugData = value; }
        }
 
        public int ImageID
        {
            get { return m_nImageID; }
            set { m_nImageID = value; }
        }
 
        public int ImageIdx
        {
            get { return m_nImageIdx; }
            set { m_nImageIdx = value; }
        }
 
        public int CreatorID
        {
            get { return m_nCreatorID; }
            set { m_nCreatorID = value; }
        }
 
        public int DatasetID
        {
            get { return m_nDatasetID; }
            set { m_nDatasetID = value; }
        }
 
        public int SourceID
        {
            get { return m_nSourceID; }
            set { m_nSourceID = value; }
        }
 
        public Dictionary<int, string> Labels
        {
            get { return m_rgLabels; }
            set { m_rgLabels = value; }
        }
 
        public int Count
        {
            get { return m_rgItems.Count; }
        }
 
        public AnnotationGroup this[int nIdx]
        {
            get { return m_rgItems[nIdx]; }
            set { m_rgItems[nIdx] = value; }
        }
 
        public void Add(AnnotationGroupCollection col)
        {
            foreach (AnnotationGroup g in col)
            {
                m_rgItems.Add(g);
            }
        }
 
        public void Add(AnnotationGroup g)
        {
            m_rgItems.Add(g);
        }
 
        public bool Remove(AnnotationGroup g)
        {
            return m_rgItems.Remove(g);
        }
 
        public void RemoveAt(int nIdx)
        {
            m_rgItems.RemoveAt(nIdx);
        }
 
        public void Clear()
        {
            m_rgItems.Clear();
        }
 
        public IEnumerator<AnnotationGroup> GetEnumerator()
        {
            return m_rgItems.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return m_rgItems.GetEnumerator();
        }
 
        public Annotation GetMaxScoringAnnotation()
        {
            Annotation bestAnnotation = null;
            float fMaxScore = 0;
 
            foreach (AnnotationGroup g in m_rgItems)
            {
                Annotation a = g.GetMaxScoringAnnotation();
 
                if (a != null && a.bbox.score >= fMaxScore)
                {
                    fMaxScore = a.bbox.score;
                    bestAnnotation = a;
                }
            }
 
            return bestAnnotation;
        }
 
        public AnnotationGroup Find(int nLabel)
        {
            foreach (AnnotationGroup g in m_rgItems)
            {
                if (g.group_label == nLabel)
                    return g;
            }
 
            return null;
        }
 
        public AnnotationGroupCollection Clone()
        {
            AnnotationGroupCollection col = new AnnotationGroupCollection();
 
            foreach (AnnotationGroup g in m_rgItems)
            {
                col.Add(g.Clone());
            }
 
            foreach (KeyValuePair<int, string> kv in m_rgLabels)
            {
                col.m_rgLabels.Add(kv.Key, kv.Value);
            }
 
            col.ImageID = m_nImageID;
            col.ImageIdx = m_nImageIdx;
            col.CreatorID = m_nCreatorID;
            col.DatasetID = m_nDatasetID;
            col.SourceID = m_nSourceID;
            col.HasDataCriteria = m_bHasDataCriteria;
            col.HasDebugData = m_bHasDebugData;
 
            return col;
        }
 
        public Tuple<int, int> GetMinMaxLabels()
        {
            int nMin = int.MaxValue;
            int nMax = -int.MaxValue;
 
            for (int i = 0; i < m_rgItems.Count; i++)
            {
                nMin = Math.Min(nMin, m_rgItems[i].group_label);
                nMax = Math.Max(nMax, m_rgItems[i].group_label);
            }
 
            return new Tuple<int, int>(nMin, nMax);
        }
 
        public void Normalize(Rectangle rc)
        {
            foreach (AnnotationGroup g in m_rgItems)
            {
                g.Normalize(rc);
            }
        }
 
        public static void SaveList(BinaryWriter bw, AnnotationGroupCollection rg)
        {
            bw.Write(rg.Count);
 
            foreach (AnnotationGroup g in rg)
            {
                g.Save(bw);
            }
 
            bw.Write(rg.ImageID);
            bw.Write(rg.ImageIdx);
            bw.Write(rg.CreatorID);
            bw.Write(rg.DatasetID);
            bw.Write(rg.SourceID);
            bw.Write(rg.HasDataCriteria);
            bw.Write(rg.HasDebugData);
        }
 
        public static void SaveLabels(BinaryWriter bw, AnnotationGroupCollection rg)
        {
            bw.Write(rg.Labels.Count);
            foreach (KeyValuePair<int, string> kv in rg.Labels)
            {
                bw.Write(kv.Key);
                bw.Write(kv.Value);
            }
        }
 
        public static AnnotationGroupCollection LoadList(BinaryReader br)
        {
            AnnotationGroupCollection rg = new AnnotationGroupCollection();
            int nCount = br.ReadInt32();
 
            for (int i = 0; i < nCount; i++)
            {
                rg.Add(AnnotationGroup.Load(br));
            }
 
            rg.ImageID = br.ReadInt32();
            rg.ImageIdx = br.ReadInt32();
            rg.CreatorID = br.ReadInt32();
            rg.DatasetID = br.ReadInt32();
            rg.SourceID = br.ReadInt32();
            rg.HasDataCriteria = br.ReadBoolean();
            rg.HasDebugData = br.ReadBoolean();
 
            return rg;
        }
 
        public static Dictionary<int, string> LoadLabels(BinaryReader br)
        {
            Dictionary<int, string> rg = new Dictionary<int, string>();
 
            int nCount = br.ReadInt32();
            for (int i = 0; i < nCount; i++)
            {
                int nKey = br.ReadInt32();
                string strVal = br.ReadString();
 
                rg.Add(nKey, strVal);
            }
 
            return rg;
        }
 
        public static byte[] ToByteArray(AnnotationGroupCollection rg, bool bIncludeLabels = false)
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                SaveList(bw, rg);
 
                bw.Write(bIncludeLabels);
                if (bIncludeLabels)
                    SaveLabels(bw, rg);
 
                bw.Write(rg.ImageID);
                bw.Write(rg.ImageIdx);
                bw.Write(rg.CreatorID);
                bw.Write(rg.DatasetID);
                bw.Write(rg.SourceID);
                bw.Write(rg.HasDataCriteria);
                bw.Write(rg.HasDebugData);
 
                ms.Flush();
                return ms.ToArray();
            }
        }
 
        public static AnnotationGroupCollection FromByteArray(byte[] rg)
        {
            using (MemoryStream ms = new MemoryStream(rg))
            using (BinaryReader br = new BinaryReader(ms))
            {
                AnnotationGroupCollection col = LoadList(br);
 
                if (br.ReadBoolean())
                    col.Labels = LoadLabels(br);
 
                col.ImageID = br.ReadInt32();
                col.ImageIdx = br.ReadInt32();
                col.CreatorID = br.ReadInt32();
                col.DatasetID = br.ReadInt32();
                col.SourceID = br.ReadInt32();
                col.HasDataCriteria = br.ReadBoolean();
                col.HasDebugData = br.ReadBoolean();
 
                return col;
            }
        }
    }
}