SimpleDatum.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Text;
using System.Threading;
 
namespace MyCaffe.basecode
{
    [Serializable]
    public class SimpleTemporalDatum
    {
        int m_nChannels = 0;
        int m_nWidth = 0;
        int m_nHeight = 0;
        float[] m_rgReadDataF = null;
 
        public SimpleTemporalDatum(int nChannels, int nWidth, int nHeight, float[] rgData)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_rgReadDataF = rgData;
        }
 
        public float[] Data
        {
            get { return m_rgReadDataF; }
            set { m_rgReadDataF = value; }
        }
 
        public int ItemCount
        {
            get
            {
                return m_rgReadDataF.Length;
            }
        }
 
        public int Channels
        {
            get { return m_nChannels; }
        }
 
        public int Width
        {
            get { return m_nWidth; }
        }
 
        public int Height
        {
            get { return m_nHeight; }
        }
    }
 
    [Serializable]
    public class SimpleTemporalDatumCollection
    {
        List<SimpleTemporalDatum> m_rgItems;
 
        public SimpleTemporalDatumCollection(int nCapacity)
        {
            m_rgItems = new List<SimpleTemporalDatum>(nCapacity);
        }
 
        public void Add(SimpleDatum sd)
        {
            SimpleTemporalDatum sdt = null;
 
            if (sd != null)
            {
                float[] rgData = sd.RealDataF;
 
                if (rgData == null && sd.RealDataD != null)
                {
                    rgData = new float[sd.RealDataD.Length];
                    for (int i = 0; i < rgData.Length; i++)
                    {
                        rgData[i] = (float)sd.RealDataD[i];
                    }
                }
 
                sdt = new SimpleTemporalDatum(sd.Channels, sd.Width, sd.Height, rgData);
            }
 
            m_rgItems.Add(sdt);
        }
 
        public int Count
        {
            get { return m_rgItems.Count; }
        }
 
        public SimpleTemporalDatum this[int nIdx]
        {
            get { return m_rgItems[nIdx]; }
        }
 
        public void Clear()
        {
            m_rgItems.Clear();
        }
    }
 
    [Serializable]
    public class SimpleDatum 
    {
        int m_nIndex = 0;
        int m_nOriginalLabel = 0;
        int m_nLabel = 0;
        int m_nHeight = 0;
        int m_nWidth = 0;
        int m_nChannels = 0;
        byte[] m_rgByteData = null;
        float[] m_rgRealDataF = null;
        double[] m_rgRealDataD = null;
        bool m_bIsRealData = false;
        DateTime m_dt = DateTime.MinValue;
        int m_nOriginalBoost = 0;
        int m_nBoost = 0;
        bool m_bAutoLabeled = false;
        int m_nImageID = 0;
        int m_nVirtualID = 0;
        int m_nGroupID = 0;
        byte[] m_rgDataCriteria = null;
        DATA_FORMAT m_dataCriteriaFormat = DATA_FORMAT.NONE;
        byte[] m_rgDebugData = null;
        DATA_FORMAT m_debugDataFormat = DATA_FORMAT.NONE;
        string m_strDesc = null;
        int m_nSourceID = 0;
        int m_nOriginalSourceID = 0;
        int m_nHitCount = 0;
        ANNOTATION_TYPE m_nAnnotationType = ANNOTATION_TYPE.NONE;
        AnnotationGroupCollection m_rgAnnotationGroup = null;
        protected object m_tag = null;
        protected string m_strTagName = null;
 
        [Serializable]
        [DataContract]
        public enum ANNOTATION_TYPE
        {
            [EnumMember]
            NONE = -1,
            [EnumMember]
            BBOX = 0
        }
 
        [Serializable]
        [DataContract]
        public enum DATA_FORMAT
        {
            [EnumMember]
            NONE,
            [EnumMember]
            IMAGE_1CH,
            [EnumMember]
            IMAGE_3CH,
            [EnumMember]
            SEGMENTATION,
            [EnumMember]
            DICTIONARY,
            [EnumMember]
            CUSTOM,
            [EnumMember]
            BITMAP,
            [EnumMember]
            LIST_DOUBLE,
            [EnumMember]
            LIST_FLOAT,
            [EnumMember]
            ANNOTATION_DATA
        }
 
 
        public SimpleDatum()
        {
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel = -1, DateTime? dtTime = null, int nBoost = 0, bool bAutoLabeled = false, int nIdx = -1, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime.GetValueOrDefault(DateTime.MinValue);
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, List<byte> rgData, int nBoost, bool bAutoLabeled, int nIdx, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
 
            if (bIsReal)
                throw new ArgumentException("The data sent is not real, but the bIsReal is set to true!");
 
            m_rgByteData = rgData.ToArray();
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, List<double> rgfData, int nBoost, bool bAutoLabeled, int nIdx, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
 
            if (!bIsReal)
                throw new ArgumentException("The data sent is real, but the bIsReal is set to false!");
 
            m_rgRealDataD = rgfData.ToArray();
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, List<float> rgfData, int nBoost, bool bAutoLabeled, int nIdx, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
 
            if (!bIsReal)
                throw new ArgumentException("The data sent is real, but the bIsReal is set to false!");
 
            m_rgRealDataF = rgfData.ToArray();
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, byte[] rgData, int nBoost, bool bAutoLabeled, int nIdx, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
 
            if (bIsReal)
                throw new ArgumentException("The data sent is not real, but the bIsReal is set to true!");
 
            m_rgByteData = rgData;
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, double[] rgdfData, int nBoost, bool bAutoLabeled, int nIdx, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
 
            if (!bIsReal)
                throw new ArgumentException("The data sent is real, but the bIsReal is set to false!");
 
            m_rgRealDataD = rgdfData;
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, float[] rgfData, int nBoost, bool bAutoLabeled, int nIdx, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
 
            if (!bIsReal)
                throw new ArgumentException("The data sent is real, but the bIsReal is set to false!");
 
            m_rgRealDataF = rgfData;
        }
 
        public SimpleDatum(bool bIsReal, int nChannels, int nWidth, int nHeight, int nLabel, DateTime dtTime, int nBoost = 0, bool bAutoLabeled = false, int nIdx = -1, int nVirtualID = 0, int nImageID = 0, int nSourceID = 0, int nOriginalSourceID = 0)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = nLabel;
            m_nLabel = nLabel;
            m_dt = dtTime;
            m_nOriginalBoost = nBoost;
            m_nBoost = nBoost;
            m_bAutoLabeled = bAutoLabeled;
            m_nVirtualID = nVirtualID;
            m_bIsRealData = bIsReal;
            m_nIndex = nIdx;
            m_nImageID = nImageID;
            m_nSourceID = nSourceID;
            m_nOriginalSourceID = nOriginalSourceID;
            m_rgByteData = null;
            m_rgRealDataD = null;
            m_rgRealDataF = null;
        }
 
        public SimpleDatum(int nChannels, int nWidth, int nHeight, float[] rgf, int nOffset, int nCount, bool bDataIsReal = true)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = 0;
            m_nOriginalBoost = 0;
            m_dt = DateTime.MinValue;
            m_bAutoLabeled = false;
            m_nVirtualID = 0;
            m_nImageID = 0;
            m_nImageID = 0;
            m_nSourceID = 0;
            m_nOriginalSourceID = 0;
            m_rgByteData = null;
 
            int nLen = nChannels * nWidth * nHeight;
            if (nLen != nCount)
                throw new Exception("The channel x width x height should equal the count!");
 
            if (bDataIsReal)
            {
                m_bIsRealData = true;
                m_rgRealDataF = new float[nCount];
 
                if (rgf != null)    
                    Array.Copy(rgf, nOffset, m_rgRealDataF, 0, nCount);
            }
            else
            {
                m_bIsRealData = false;
                m_rgByteData = new byte[nCount];
 
                for (int i = 0; i < nCount; i++)
                {
                    m_rgByteData[i] = Math.Min(Math.Max((byte)rgf[nOffset + i], (byte)0), (byte)255);
                }
            }
        }
 
        public SimpleDatum(int nChannels, int nWidth, int nHeight)
        {
            m_nChannels = nChannels;
            m_nWidth = nWidth;
            m_nHeight = nHeight;
            m_nOriginalLabel = 0;
            m_nOriginalBoost = 0;
            m_dt = DateTime.MinValue;
            m_bAutoLabeled = false;
            m_nVirtualID = 0;
            m_nImageID = 0;
            m_nImageID = 0;
            m_nSourceID = 0;
            m_nOriginalSourceID = 0;
            m_rgByteData = null;
        }
 
        public SimpleDatum(Bytemap data)
        {
            m_nChannels = data.Channels;
            m_nWidth = data.Width;
            m_nHeight = data.Height;
            m_nOriginalLabel = -1;
            m_nLabel = -1;
            m_bIsRealData = false;
 
            m_rgByteData = data.Bytes;
        }
 
        public SimpleDatum(Valuemap data)
        {
            m_nChannels = data.Channels;
            m_nWidth = data.Width;
            m_nHeight = data.Height;
            m_nOriginalLabel = -1;
            m_nLabel = -1;
            m_bIsRealData = true;
 
            m_rgRealDataD = data.Values;
        }
 
        public SimpleDatum(SimpleDatum d, bool bCopyData = false)
        {
            Copy(d, bCopyData);
        }
 
        public SimpleDatum(SimpleDatum d, int nHeight, int nWidth)
        {
            Copy(d, false, nHeight, nWidth);
        }
 
        public SimpleDatum(List<SimpleDatum> rg, bool bAlignChannels)
        {
            if (rg.Count == 1)
            {
                Copy(rg[0], true);
                return;
            }
 
            Copy(rg[0], false);
 
            m_nChannels *= rg.Count;
 
            if (bAlignChannels)
            {
                if (m_nChannels != rg.Count)
                    throw new Exception("Currently channel alignment is only allowed on single channel data.");
 
                if (rg.Count >= 1)
                {
                    if (rg[0].IsRealData)
                    {
                        if (rg[0].RealDataD != null)
                        {
                            double[] rgData = new double[m_nChannels * Height * Width];
 
                            for (int h = 0; h < Height; h++)
                            {
                                for (int w = 0; w < Width; w++)
                                {
                                    int nIdxSrc = (h * Width) + w;
                                    int nIdxDst = nIdxSrc * m_nChannels;
 
                                    for (int c = 0; c < m_nChannels; c++)
                                    {
                                        rgData[nIdxDst + c] = rg[c].RealDataD[nIdxSrc];
                                    }
                                }
                            }
 
                            m_rgRealDataD = rgData;
                        }
                        else if (rg[0].RealDataF != null)
                        {
                            float[] rgData = new float[m_nChannels * Height * Width];
 
                            for (int h = 0; h < Height; h++)
                            {
                                for (int w = 0; w < Width; w++)
                                {
                                    int nIdxSrc = (h * Width) + w;
                                    int nIdxDst = nIdxSrc * m_nChannels;
 
                                    for (int c = 0; c < m_nChannels; c++)
                                    {
                                        rgData[nIdxDst + c] = rg[c].RealDataF[nIdxSrc];
                                    }
                                }
                            }
 
                            m_rgRealDataF = rgData;
                        }
                        else
                        {
                            throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                        }
                        m_rgByteData = null;
                    }
                    else
                    {
                        byte[] rgData = new byte[m_nChannels * Height * Width];
 
                        for (int h = 0; h < Height; h++)
                        {
                            for (int w = 0; w < Width; w++)
                            {
                                int nIdxSrc = (h * Width) + w;
                                int nIdxDst = nIdxSrc * m_nChannels;
 
                                for (int c = 0; c < m_nChannels; c++)
                                {
                                    rgData[nIdxDst + c] = rg[c].ByteData[nIdxSrc];
                                }
                            }
                        }
 
                        m_rgByteData = rgData;
                        m_rgRealDataF = null;
                        m_rgRealDataD = null;
                    }
                }
            }
            else
            {
                bool bReal = rg[0].IsRealData;
                int nDstIdx = 0;
                int nItemCount = m_nChannels / rg.Count;
 
                if (bReal)
                {
                    if (rg[0].RealDataD != null)
                    {
                        m_rgRealDataD = new double[m_nChannels * Height * Width];
                        m_rgByteData = null;
 
                        for (int i = 0; i < rg.Count; i++)
                        {
                            Array.Copy(rg[i].RealDataD, 0, m_rgRealDataD, nDstIdx, nItemCount);
                            nDstIdx += nItemCount;
                        }
                    }
                    else if (rg[0].RealDataF != null)
                    {
                        m_rgRealDataF = new float[m_nChannels * Height * Width];
                        m_rgByteData = null;
 
                        for (int i = 0; i < rg.Count; i++)
                        {
                            Array.Copy(rg[i].RealDataF, 0, m_rgRealDataF, nDstIdx, nItemCount);
                            nDstIdx += nItemCount;
                        }
                    }
                    else
                    {
                        throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                    }
                }
                else
                {
                    m_rgByteData = new byte[m_nChannels * Height * Width];
                    m_rgRealDataD = null;
                    m_rgRealDataF = null;
 
                    for (int i = 0; i < rg.Count; i++)
                    {
                        Array.Copy(rg[i].ByteData, 0, m_rgByteData, nDstIdx, nItemCount);
                        nDstIdx += nItemCount;
                    }
                }
            }
        }
 
        public int HitCount
        {
            get { return m_nHitCount; }
            set { m_nHitCount = value; }
        }
 
        public object Tag
        {
            get { return m_tag; }
            set { m_tag = value; }
        }
 
        public string TagName
        {
            get { return m_strTagName; }
            set { m_strTagName = value; }
        }
 
        public double Min
        {
            get
            {
                if (m_bIsRealData)
                {
                    if (m_rgRealDataD != null)
                        return m_rgRealDataD.Min(p => p);
                    else if (m_rgRealDataF != null)
                        return m_rgRealDataF.Min(p => p);
                    else
                        throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
                else
                {
                    if (m_rgByteData != null)
                        return (double)m_rgByteData.Min(p => p);
                }
 
                return double.NaN;
            }
        }
 
        public double Max
        {
            get
            {
                if (m_bIsRealData)
                {
                    if (m_rgRealDataD != null)
                        return m_rgRealDataD.Max(p => p);
                    else if (m_rgRealDataF != null)
                        return m_rgRealDataF.Max(p => p);
                    else
                        throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
                else
                {
                    if (m_rgByteData != null)
                        return (double)m_rgByteData.Max(p => p);
                }
 
                return double.NaN;
            }
        }
 
        public void Clip(int nDataLen, int? nNewChannel, int? nNewHeight, int? nNewWidth)
        {           
            if (m_rgByteData != null && m_rgByteData.Length > nDataLen)
            {
                byte[] rgData = new byte[nDataLen];
                Array.Copy(m_rgByteData, rgData, nDataLen);
                m_rgByteData = rgData;
            }
            if (m_rgRealDataD != null && m_rgRealDataD.Length > nDataLen)
            {
                double[] rgData = new double[nDataLen];
                Array.Copy(m_rgRealDataD, rgData, nDataLen);
                m_rgRealDataD = rgData;
            }
            if (m_rgRealDataF != null && m_rgRealDataF.Length > nDataLen)
            {
                float[] rgData = new float[nDataLen];
                Array.Copy(m_rgRealDataF, rgData, nDataLen);
                m_rgRealDataF = rgData;
            }
 
            m_nChannels = nNewChannel.GetValueOrDefault(m_nChannels);
            m_nHeight = nNewHeight.GetValueOrDefault(m_nHeight);
            m_nWidth = nNewWidth.GetValueOrDefault(m_nWidth);
        }
 
        public List<int> GetNonZeroIndexes()
        {
            List<int> rgIdx = new List<int>();
 
            if (m_bIsRealData)
            {
                if (m_rgRealDataD != null)
                {
                    for (int i = 0; i < m_rgRealDataD.Length; i++)
                    {
                        if (m_rgRealDataD[i] != 0)
                            rgIdx.Add(i);
                    }
                }
                else if (m_rgRealDataF != null)
                {
                    for (int i = 0; i < m_rgRealDataF.Length; i++)
                    {
                        if (m_rgRealDataF[i] != 0)
                            rgIdx.Add(i);
                    }
                }
                else
                {
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
            }
            else
            {
                for (int i = 0; i < m_rgByteData.Length; i++)
                {
                    if (m_rgByteData[i] != 0)
                        rgIdx.Add(i);
                }
            }
 
            return rgIdx;
        }
 
        public void Zero()
        {
            if (m_rgByteData != null)
                Array.Clear(m_rgByteData, 0, m_rgByteData.Length);
 
            if (m_rgRealDataD != null)
                Array.Clear(m_rgRealDataD, 0, m_rgRealDataD.Length);
 
            if (m_rgRealDataF != null)
                Array.Clear(m_rgRealDataF, 0, m_rgRealDataF.Length);
        }
 
        public bool Sub(SimpleDatum sd, bool bSetNegativeToZero = false)
        {
            bool bDifferent = false;
 
            if (sd.ItemCount != ItemCount)
                throw new Exception("Both simple datums must have the same number of elements!");
 
            if (m_rgByteData != null)
            {
                for (int i = 0; i < m_rgByteData.Length; i++)
                {
                    int nVal = 0;
 
                    if (sd.m_rgByteData != null)
                        nVal = m_rgByteData[i] - sd.m_rgByteData[i];
                    else if (sd.m_rgRealDataD != null)
                        nVal = (int)m_rgByteData[i] - (int)sd.m_rgRealDataD[i];
                    else if (sd.m_rgRealDataF != null)
                        nVal = (int)m_rgByteData[i] - (int)sd.m_rgRealDataF[i];
 
                    if (nVal != 0)
                    {
                        bDifferent = true;
 
                        if (bSetNegativeToZero && nVal < 0)
                            nVal = 0;
                    }
 
                    m_rgByteData[i] = (byte)nVal;
                }
            }
 
            if (m_rgRealDataD != null)
            {
                for (int i = 0; i < m_rgRealDataD.Length; i++)
                {
                    if (sd.m_rgRealDataD != null)
                        m_rgRealDataD[i] -= sd.m_rgRealDataD[i];
                    else if (sd.m_rgRealDataF != null)
                        m_rgRealDataD[i] -= sd.m_rgRealDataF[i];
                    else if (sd.m_rgByteData != null)
                        m_rgRealDataD[i] -= sd.m_rgByteData[i];
 
                    if (m_rgRealDataD[i] != 0)
                    {
                        bDifferent = true;
 
                        if (bSetNegativeToZero && m_rgRealDataD[i] < 0)
                            m_rgRealDataD[i] = 0;
                    }
                }
            }
 
            if (m_rgRealDataF != null)
            {
                for (int i = 0; i < m_rgRealDataF.Length; i++)
                {
                    if (sd.m_rgRealDataD != null)
                        m_rgRealDataF[i] -= (float)sd.m_rgRealDataD[i];
                    else if (sd.m_rgRealDataF != null)
                        m_rgRealDataF[i] -= sd.m_rgRealDataF[i];
                    else if (sd.m_rgByteData != null)
                        m_rgRealDataF[i] -= sd.m_rgByteData[i];
 
                    if (m_rgRealDataF[i] != 0)
                    {
                        bDifferent = true;
 
                        if (bSetNegativeToZero && m_rgRealDataF[i] < 0)
                            m_rgRealDataF[i] = 0;
                    }
                }
            }
 
            return bDifferent;
        }
 
        public bool SubAbs(SimpleDatum sd)
        {
            bool bDifferent = false;
 
            if (sd.ItemCount != ItemCount)
                throw new Exception("Both simple datums must have the same number of elements!");
 
            if (m_rgByteData != null)
            {
                if (sd.m_rgByteData == null)
                    throw new Exception("Both simple datums must have the same type of data!");
 
                for (int i = 0; i < m_rgByteData.Length; i++)
                {
                    m_rgByteData[i] = (byte)Math.Abs(m_rgByteData[i] - sd.m_rgByteData[i]);
                    if (m_rgByteData[i] != 0)
                        bDifferent = true;
                }
            }
 
            if (m_rgRealDataD != null)
            {
                if (sd.m_rgRealDataD == null)
                    throw new Exception("Both simple datums must have the same type of data!");
 
                for (int i = 0; i < m_rgRealDataD.Length; i++)
                {
                    m_rgRealDataD[i] = Math.Abs(m_rgRealDataD[i] - sd.m_rgRealDataD[i]);
                    if (m_rgRealDataD[i] != 0)
                        bDifferent = true;
                }
            }
 
            if (m_rgRealDataF != null)
            {
                if (sd.m_rgRealDataF == null)
                    throw new Exception("Both simple datums must have the same type of data!");
 
                for (int i = 0; i < m_rgRealDataF.Length; i++)
                {
                    m_rgRealDataF[i] = Math.Abs(m_rgRealDataF[i] - sd.m_rgRealDataF[i]);
                    if (m_rgRealDataF[i] != 0)
                        bDifferent = true;
                }
            }
 
            return bDifferent;
        }
 
        public void Scale(double dfScale, double dfMin = -double.MaxValue, double dfMax = double.MaxValue)
        {
            if (m_rgByteData != null)
            {
                for (int i = 0; i < m_rgByteData.Length; i++)
                {
                    int nVal = (int)(m_rgByteData[i] * dfScale);
                    if (nVal < (int)dfMin)
                        nVal = (int)dfMin;
                    else if (nVal > (int)dfMax)
                        nVal = (int)dfMax;
                    m_rgByteData[i] = (byte)nVal;
                }
            }
 
            if (m_rgRealDataD != null)
            {
                for (int i = 0; i < m_rgRealDataD.Length; i++)
                {
                    m_rgRealDataD[i] *= dfScale;
                    if (m_rgRealDataD[i] < dfMin)
                        m_rgRealDataD[i] = dfMin;
                    else if (m_rgRealDataD[i] > dfMax)
                        m_rgRealDataD[i] = dfMax;
                }
            }
 
            if (m_rgRealDataF != null)
            {
                for (int i = 0; i < m_rgRealDataF.Length; i++)
                {
                    m_rgRealDataF[i] *= (float)dfScale;
                    if (m_rgRealDataF[i] < dfMin)
                        m_rgRealDataF[i] = (float)dfMin;
                    else if (m_rgRealDataF[i] > dfMax)
                        m_rgRealDataF[i] = (float)dfMax;
                }
            }
        }
 
        public void ScalePow(double dfScalePow, double dfMin = -double.MaxValue, double dfMax = double.MaxValue)
        {
            if (m_rgByteData != null)
            {
                for (int i = 0; i < m_rgByteData.Length; i++)
                {
                    int nVal = (int)((double)Math.Pow(m_rgByteData[i], dfScalePow));
                    if (nVal < (int)dfMin)
                        nVal = (int)dfMin;
                    else if (nVal > (int)dfMax)
                        nVal = (int)dfMax;
                    m_rgByteData[i] = (byte)nVal;
                }
            }
 
            if (m_rgRealDataD != null)
            {
                for (int i = 0; i < m_rgRealDataD.Length; i++)
                {
                    m_rgRealDataD[i] = Math.Pow(m_rgRealDataD[i], dfScalePow);
                    if (m_rgRealDataD[i] < dfMin)
                        m_rgRealDataD[i] = dfMin;
                    else if (m_rgRealDataD[i] > dfMax)
                        m_rgRealDataD[i] = dfMax;
                }
            }
 
            if (m_rgRealDataF != null)
            {
                for (int i = 0; i < m_rgRealDataF.Length; i++)
                {
                    m_rgRealDataF[i] = (float)(Math.Pow(m_rgRealDataF[i], dfScalePow));
                    if (m_rgRealDataF[i] < dfMin)
                        m_rgRealDataF[i] = (float)dfMin;
                    else if (m_rgRealDataF[i] > dfMax)
                        m_rgRealDataF[i] = (float)dfMax;
                }
            }
        }
 
        public void Copy(SimpleDatum d, bool bCopyData, int? nHeight = null, int? nWidth = null)
        {
            m_bIsRealData = d.m_bIsRealData;
            m_nLabel = d.m_nLabel;
            m_nOriginalLabel = d.m_nOriginalLabel;
            m_nChannels = d.m_nChannels;
            m_nHeight = nHeight.GetValueOrDefault(d.m_nHeight);
            m_nWidth = nWidth.GetValueOrDefault(d.m_nWidth);
 
            if (bCopyData)
            {
                m_rgRealDataD = Utility.Clone<double>(d.m_rgRealDataD);
                m_rgRealDataF = Utility.Clone<float>(d.m_rgRealDataF);
                m_rgByteData = Utility.Clone<byte>(d.m_rgByteData);
            }
            else
            {
                m_rgRealDataD = d.m_rgRealDataD;
                m_rgRealDataF = d.m_rgRealDataF;
                m_rgByteData = d.m_rgByteData;
            }
 
            m_dt = d.m_dt;
            m_nOriginalBoost = d.m_nOriginalBoost;
            m_nBoost = d.m_nBoost;
            m_bAutoLabeled = d.m_bAutoLabeled;
            m_nImageID = d.m_nImageID;
            m_nVirtualID = d.m_nVirtualID;
            m_nGroupID = d.m_nGroupID;
            m_nIndex = d.m_nIndex;
            m_strDesc = d.m_strDesc;
            m_rgDataCriteria = d.m_rgDataCriteria;
            m_dataCriteriaFormat = d.m_dataCriteriaFormat;
            m_rgDebugData = d.m_rgDebugData;
            m_debugDataFormat = d.m_debugDataFormat;
            m_nSourceID = d.m_nSourceID;
            m_nOriginalSourceID = d.m_nOriginalSourceID;
            m_tag = d.m_tag;
            m_strTagName = d.m_strTagName;
 
            m_nAnnotationType = d.m_nAnnotationType;
            m_rgAnnotationGroup = null;
 
            if (d.m_rgAnnotationGroup != null)
            {
                m_rgAnnotationGroup = new AnnotationGroupCollection();
 
                foreach (AnnotationGroup g in d.m_rgAnnotationGroup)
                {
                    m_rgAnnotationGroup.Add(g.Clone());
                }
            }
        }
 
        public void CopyData(SimpleDatum d)
        {
            m_nHeight = d.m_nHeight;
            m_nWidth = d.m_nWidth;
            m_nChannels = d.m_nChannels;
            m_rgByteData = d.m_rgByteData;
            m_bIsRealData = d.m_bIsRealData;
            m_rgRealDataD = d.m_rgRealDataD;
            m_rgRealDataF = d.m_rgRealDataF;
        }
 
        public void SetData(SimpleDatum d)
        {
            if (d.IsRealData)
            {
                if (d.RealDataD != null)
                    SetData(d.RealDataD.ToList(), d.Label);
                else if (d.RealDataF != null)
                    SetData(d.RealDataF.ToList(), d.Label);
                else
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
            }
            else
                SetData(d.ByteData.ToList(), d.Label);
        }
 
        public bool GetDataValid(bool bByType = true)
        {
            if (bByType)
            {
                if (m_bIsRealData && m_rgRealDataD == null && m_rgRealDataF == null)
                    return false;
                else if (!m_bIsRealData && m_rgByteData == null)
                    return false;
 
                return true;
            }
 
            if (m_rgRealDataD == null && m_rgRealDataF == null && m_rgByteData == null)
                return false;
 
            return true;
        }
 
        public List<T> ClipToLastColumnsX<T>(int nLastColumns = 10)
        {
            int nC = m_nChannels;
            int nW = m_nWidth;
            int nH = m_nHeight;
            int nXStart = nW - nLastColumns;
            List<T> rg = new List<T>();
 
            if (nXStart < 0)
                nXStart = 0;
 
            for (int c = 0; c < nC; c++)
            {
                for (int y = 0; y < nH; y++)
                {
                    for (int x = nXStart; x < nW; x++)
                    {
                        int nIdxImg = (c * (nH * nW)) + (y * nW) + x;
                        rg.Add((T)Convert.ChangeType(ByteData[nIdxImg], typeof(T)));
                    }
                }
            }
 
            return rg;
        }
 
        public void MaskOutAllButLastColumnsX(int nLastColumsToRetain, int nMaskingValue)
        {
            if (nLastColumsToRetain <= 0 || nLastColumsToRetain >= m_nWidth)
                return;
 
            int nC = m_nChannels;
            int nW = m_nWidth;
            int nH = m_nHeight;
            int nMaskWid = nW - nLastColumsToRetain;
 
            for (int c = 0; c < nC; c++)
            {
                for (int y = 0; y < nH; y++)
                {
                    for (int x = 0; x < nMaskWid; x++)
                    {
                        int nIdxImg = (c * (nH * nW)) + (y * nW) + x;
                        ByteData[nIdxImg] = (byte)nMaskingValue;
                    }
                }
            }
        }
 
        public void SetData(List<byte> rgByteData, int nLabel, bool bAllowVirtualOverride = false)
        {
            if (!bAllowVirtualOverride && m_nVirtualID != 0)
                throw new Exception("Cannot set the data of a virtual item!");
 
            m_nVirtualID = 0;
            m_bIsRealData = false;
            m_rgByteData = rgByteData.ToArray();
            m_rgRealDataD = null;
            m_rgRealDataF = null;
            m_nLabel = nLabel;
        }
 
        public void SetData(List<double> rgRealData, int nLabel, bool bAllowVirtualOverride = false)
        {
            if (!bAllowVirtualOverride && m_nVirtualID != 0)
                throw new Exception("Cannot set the data of a virtual item!");
 
            m_nVirtualID = 0;
            m_bIsRealData = true;
            m_rgByteData = null;
            m_rgRealDataF = null;
            m_rgRealDataD = rgRealData.ToArray();
            m_nLabel = nLabel;
        }
 
        public void SetData(List<float> rgRealData, int nLabel, bool bAllowVirtualOverride = false)
        {
            if (!bAllowVirtualOverride && m_nVirtualID != 0)
                throw new Exception("Cannot set the data of a virtual item!");
 
            m_nVirtualID = 0;
            m_bIsRealData = true;
            m_rgByteData = null;
            m_rgRealDataD = null;
            m_rgRealDataF = rgRealData.ToArray();
            m_nLabel = nLabel;
        }
 
        public void SetData(byte[] rgb, int nLabel)
        {
            m_nLabel = nLabel;
            m_rgByteData = new byte[rgb.Length];
            Array.Copy(rgb, m_rgByteData, rgb.Length);
            m_bIsRealData = false;
            m_rgRealDataD = null;
            m_rgRealDataF = null;
        }
 
        public void SetData(double[] rgdf, int nLabel)
        {
            m_nLabel = nLabel;
            m_rgRealDataF = null;
            m_rgRealDataD = new double[rgdf.Length];
            Array.Copy(rgdf, m_rgRealDataD, rgdf.Length);
            m_rgByteData = null;
            m_bIsRealData = true;
        }
 
        public void SetData(float[] rgf, int nLabel)
        {
            m_nLabel = nLabel;
            m_rgRealDataD = null;
            m_rgRealDataF = new float[rgf.Length];
            Array.Copy(rgf, m_rgRealDataF, rgf.Length);
            m_rgByteData = null;
            m_bIsRealData = true;
        }
 
        public void SetLabel(int nLabel)
        {
            m_nLabel = nLabel;
        }
 
        public void ResetLabel()
        {
            m_nLabel = m_nOriginalLabel;
        }
 
        public int ItemCount
        {
            get
            {
                if (IsRealData)
                {
                    if (m_rgRealDataD != null)
                        return m_rgRealDataD.Length;
                    else if (m_rgRealDataF != null)
                        return m_rgRealDataF.Length;
                    else
                        throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
                else
                    return m_rgByteData.Length;
            }
        }
 
        public bool HasRealData
        {
            get
            {
                if (m_rgRealDataD != null && m_rgRealDataD.Length > 0)
                    return true;
 
                if (m_rgRealDataF != null && m_rgRealDataF.Length > 0)
                    return true;
 
                return false;
            }
        }
 
        public T GetDataAt<T>(int nIdx)
        {
            if (IsRealData)
            {
                if (m_rgRealDataD != null)
                    return (T)Convert.ChangeType(m_rgRealDataD[nIdx], typeof(T));
                else if (m_rgRealDataF != null)
                    return (T)Convert.ChangeType(m_rgRealDataF[nIdx], typeof(T));
                else
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
            }
            else
            {
                return (T)Convert.ChangeType(m_rgByteData[nIdx], typeof(T));
            }
        }
 
        public double GetDataAtD(int nIdx)
        {
            if (IsRealData)
            {
                if (m_rgRealDataD != null)
                    return m_rgRealDataD[nIdx];
                else if (m_rgRealDataF != null)
                    return m_rgRealDataF[nIdx];
                else
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
            }
            else
            {
                return m_rgByteData[nIdx];
            }
        }
 
        public float GetDataAtF(int nIdx)
        {
            if (IsRealData)
            {
                if (m_rgRealDataD != null)
                    return (float)m_rgRealDataD[nIdx];
                else if (m_rgRealDataF != null)
                    return m_rgRealDataF[nIdx];
                else
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
            }
            else
            {
                return m_rgByteData[nIdx];
            }
        }
 
        public byte GetDataAtByte(int nIdx)
        {
            if (IsRealData)
            {
                double dfVal = 0;
 
                if (m_rgRealDataD != null)
                    dfVal = m_rgRealDataD[nIdx];
                else if (m_rgRealDataF != null)
                    dfVal = m_rgRealDataF[nIdx];
                else
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
 
                return (byte)Math.Min(Math.Max(0, dfVal), 255);
            }
            else
            {
                return m_rgByteData[nIdx];
            }
        }
 
        public T[] GetData<T>(int nImagePadX = 0, int nImagePadY = 0)
        {
            if (IsRealData)
            {
                if (m_rgRealDataD != null)
                {
                    if (m_rgRealDataD.Length == 0)
                        return null;
 
                    if (typeof(T) == typeof(double))
                        return (T[])Convert.ChangeType(m_rgRealDataD.ToArray(), typeof(T[]));
 
                    T[] rg = new T[m_rgRealDataD.Length];
                    for (int i = 0; i < rg.Length; i++)
                    {
                        rg[i] = (T)Convert.ChangeType(m_rgRealDataD[i], typeof(T));
                    }
 
                    return rg;
                }
                else if (m_rgRealDataF != null)
                {
                    if (m_rgRealDataF.Length == 0)
                        return null;
 
                    if (typeof(T) == typeof(float))
                        return (T[])Convert.ChangeType(m_rgRealDataF.ToArray(), typeof(T[]));
 
                    T[] rg = new T[m_rgRealDataF.Length];
                    for (int i = 0; i < rg.Length; i++)
                    {
                        rg[i] = (T)Convert.ChangeType(m_rgRealDataF[i], typeof(T));
                    }
 
                    return rg;
                }
                else
                {
                    return null;
                }
            }
            else
            {
                if (m_rgByteData == null || m_rgByteData.Length == 0)
                    return null;
 
                T[] rg = new T[m_rgByteData.Length];
 
                for (int i = 0; i < rg.Length; i++)
                {
                    rg[i] = (T)Convert.ChangeType(m_rgByteData[i], typeof(T));
                }
 
                return rg;
            }
        }
 
        public static byte[] GetByteData(byte[] rgData, int nImagePadX, int nImagePadY, int nHeight, int nWidth, int nChannels)
        {
            if (nImagePadX == 0 && nImagePadY == 0)
                return rgData;
 
            return PadData<byte>(new List<byte>(rgData), nImagePadX, nImagePadY, nHeight, nWidth, nChannels);
        }
 
        public static Tuple<double[], float[]> GetRealData(byte[] rgData, int nImagePadX, int nImagePadY, int nHeight, int nWidth, int nChannels)
        {
            Tuple<double[], float[]> rgRealData = GetRealData(rgData);
 
            double[] rgRealDataD = rgRealData.Item1;
            float[] rgRealDataF = rgRealData.Item2;
 
            if (rgRealDataD != null)
                rgRealDataD = PadData<double>(rgRealDataD.ToList(), nImagePadX, nImagePadY, nHeight, nWidth, nChannels);
            else
                rgRealDataF = PadData<float>(rgRealDataF.ToList(), nImagePadX, nImagePadY, nHeight, nWidth, nChannels);
 
            return new Tuple<double[], float[]>(rgRealDataD, rgRealDataF);
        }
 
        public static T[] PadData<T>(List<T> rgData, int nImagePadX, int nImagePadY, int nHeight, int nWidth, int nChannels)
        {
            int nDstIdx = 0;
            int nCount = nChannels * (nHeight * (nImagePadX + nWidth) + (nImagePadY * nImagePadX));
            T[] rgDataNew = new T[nCount];
 
            for (int c = 0; c < nChannels; c++)
            {
                for (int y = 0; y < nHeight; y++)
                {
                    for (int i = 0; i < nImagePadX; i++)
                    {
                        rgDataNew[nDstIdx] = (T)Convert.ChangeType(0.0, typeof(T));
                        nDstIdx++;
                    }
 
                    for (int x = 0; x < nWidth; x++)
                    {
                        int nIdx = (c * nWidth * nHeight) + (y * nWidth) + x;
 
                        rgDataNew[nDstIdx] = rgData[nIdx];
                        nDstIdx++;
                    }
                }
 
                for (int i = 0; i < nImagePadY; i++)
                {
                    for (int x = 0; x < nWidth + nImagePadX; x++)
                    {
                        rgDataNew[nDstIdx] = (T)Convert.ChangeType(0.0, typeof(T));
                        nDstIdx++;
                    }
                }
            }
 
            return rgDataNew;
        }
 
        public byte[] GetByteData(out bool bEncoded)
        {
            if (!IsRealData)
            {
                bEncoded = false;
                return ByteData;
            }
 
            bEncoded = true;
 
            if (m_rgRealDataD != null)
                return GetByteData(new List<double>(m_rgRealDataD));
            else if (m_rgRealDataF != null)
                return GetByteData(new List<float>(m_rgRealDataF));
            else
                throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
        }
 
        public static byte[] GetByteData(List<double> rgData)
        {
            int nCount = rgData.Count;
            int nSize = sizeof(double);
 
            int nOffset = 0;
            int nDataCount = sizeof(int) + sizeof(int) + (nSize * rgData.Count);
            byte[] rgByte = new byte[nDataCount];
 
            byte[] rg = BitConverter.GetBytes(nCount);
            Array.Copy(rg, 0, rgByte, nOffset, rg.Length);
            nOffset += rg.Length;
 
            rg = BitConverter.GetBytes(nSize);
            Array.Copy(rg, 0, rgByte, nOffset, rg.Length);
            nOffset += rg.Length;
 
            foreach (double df in rgData)
            {
                rg = BitConverter.GetBytes(df);
                Array.Copy(rg, 0, rgByte, nOffset, rg.Length);
                nOffset += rg.Length;
            }
 
            return rgByte;
        }
 
        public static byte[] GetByteData(List<float> rgData)
        {
            int nCount = rgData.Count;
            int nSize = sizeof(float);
 
            int nOffset = 0;
            int nDataCount = sizeof(int) + sizeof(int) + (nSize * rgData.Count);
            byte[] rgByte = new byte[nDataCount];
 
            byte[] rg = BitConverter.GetBytes(nCount);
            Array.Copy(rg, 0, rgByte, nOffset, rg.Length);
            nOffset += rg.Length;
 
            rg = BitConverter.GetBytes(nSize);
            Array.Copy(rg, 0, rgByte, nOffset, rg.Length);
            nOffset += rg.Length;
 
            foreach (float df in rgData)
            {
                rg = BitConverter.GetBytes(df);
                Array.Copy(rg, 0, rgByte, nOffset, rg.Length);
                nOffset += rg.Length;
            }
 
            return rgByte;
        }
 
        public static Tuple<double[], float[]> GetRealData(byte[] rgData)
        {
            double[] rgDataD = null;
            float[] rgDataF = null;
            int nIdx = 0;
 
            int nCount = BitConverter.ToInt32(rgData, nIdx);
            nIdx += 4;
            int nSize = BitConverter.ToInt32(rgData, nIdx);
            nIdx += 4;
 
            // If the size is invalid, revert back to the legacy double only data.
            if (nSize != sizeof(float) && nSize != sizeof(double))
            {
                nIdx = 0;
                nSize = sizeof(double);
            }
 
            if (nSize == sizeof(double))
                rgDataD = getRealDataD(rgData, nIdx);
            else
                rgDataF = getRealDataF(rgData, nIdx);
 
            return new Tuple<double[], float[]>(rgDataD, rgDataF);
        }
 
        protected static double[] getRealDataD(byte[] rgData, int nIdx)
        {
            List<double> rgData0 = new List<double>();
 
            while (nIdx < rgData.Length)
            {
                rgData0.Add(BitConverter.ToDouble(rgData, nIdx));
                nIdx += 8;
            }
 
            return rgData0.ToArray();
        }
 
        protected static float[] getRealDataF(byte[] rgData, int nIdx)
        {
            List<float> rgData0 = new List<float>();
 
            while (nIdx < rgData.Length)
            {
                rgData0.Add(BitConverter.ToSingle(rgData, nIdx));
                nIdx += 8;
            }
 
            return rgData0.ToArray();
        }
 
        public SimpleDatum Add(SimpleDatum d)
        {
            if (m_nChannels != d.Channels ||
                m_nHeight != d.Height ||
                m_nWidth != d.Width)
                throw new Exception("Datum dimmensions do not match!");
 
            if (ItemCount != d.ItemCount)
                throw new Exception("Datum counts do not match!");
 
            SimpleDatum d1 = new SimpleDatum(d, false);
 
            d1.m_rgRealDataD = null;
            d1.m_rgRealDataF = null;
            d1.m_rgByteData = null;
 
            if (m_bIsRealData)
            {
                if (m_rgRealDataD != null)
                {
                    d1.m_rgRealDataD = new double[m_rgRealDataD.Length];
 
                    for (int i = 0; i < m_rgRealDataD.Length; i++)
                    {
                        d1.m_rgRealDataD[i] = m_rgRealDataD[i] + d.GetDataAtD(i);
                    }
                }
                else if (m_rgRealDataF != null)
                {
                    d1.m_rgRealDataF = new float[m_rgRealDataF.Length];
 
                    for (int i = 0; i < m_rgRealDataF.Length; i++)
                    {
                        d1.m_rgRealDataF[i] = m_rgRealDataF[i] + d.GetDataAtF(i);
                    }
                }
                else
                {
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
 
                d1.m_bIsRealData = true;
            }
            else
            {
                d1.m_rgByteData = new byte[m_rgByteData.Length];
                d1.m_bIsRealData = false;
 
                for (int i = 0; i < m_rgByteData.Length; i++)
                {
                    int nVal = m_rgByteData[i] + d.GetDataAtByte(i);
                    d1.m_rgByteData[i] = (byte)Math.Min(Math.Max(0, nVal), 255);
                }
            }
 
            return d1;
        }
 
        public SimpleDatum Div(double dfVal, bool bConvertToByte)
        {
            if (dfVal == 0)
                throw new ArgumentOutOfRangeException("dfVal", 0, "Cannot divide the simple datums by zero!");
 
            SimpleDatum d1 = new SimpleDatum(this, false);
 
            d1.m_rgRealDataD = null;
            d1.m_rgRealDataF = null;
            d1.m_rgByteData = null;
 
            int nCount = ItemCount;
 
            if (m_bIsRealData && !bConvertToByte)
            {
                if (m_rgRealDataD != null)
                {
                    d1.m_rgRealDataD = new double[nCount];
                    d1.m_bIsRealData = true;
 
                    for (int i = 0; i < nCount; i++)
                    {
                        d1.m_rgRealDataD[i] = m_rgRealDataD[i] / dfVal;
                    }
                }
                else if (m_rgRealDataF != null)
                {
                    d1.m_rgRealDataF = new float[nCount];
                    d1.m_bIsRealData = true;
 
                    for (int i = 0; i < nCount; i++)
                    {
                        d1.m_rgRealDataF[i] = (float)(m_rgRealDataF[i] / dfVal);
                    }
                }
                else
                {
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
            }
            else if (m_bIsRealData && bConvertToByte)
            {
                d1.m_rgByteData = new byte[nCount];
                d1.m_bIsRealData = false;
 
                if (m_rgRealDataD != null)
                {
                    for (int i = 0; i < nCount; i++)
                    {
                        double dfVal1 = m_rgRealDataD[i] / dfVal;
                        m_rgByteData[i] = (byte)Math.Min(Math.Max(dfVal1, 0), 255);
                    }
                }
                else if (m_rgRealDataF != null)
                {
                    for (int i = 0; i < nCount; i++)
                    {
                        double dfVal1 = m_rgRealDataF[i] / dfVal;
                        m_rgByteData[i] = (byte)Math.Min(Math.Max(dfVal1, 0), 255);
                    }
                }
                else
                {
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
            }
            else
            {
                d1.m_rgByteData = new byte[nCount];
                d1.m_bIsRealData = false;
 
                for (int i = 0; i < nCount; i++)
                {
                    double dfVal1 = (double)m_rgByteData[i] / dfVal;
                    m_rgByteData[i] = (byte)Math.Min(Math.Max(dfVal1, 0), 255);
                }
            }
 
            return d1;
        }
 
        public int SourceID
        {
            get { return m_nSourceID; }
        }
 
        public int OriginalSourceID
        {
            get { return m_nOriginalSourceID; }
        }
 
        public int ImageID
        {
            get { return m_nImageID; }            
        }
 
        public void SetImageID(int nID)
        {
            m_nImageID = nID;
        }
 
        public int VirtualID
        {
            get { return m_nVirtualID; }
        }
 
        public int GroupID
        {
            get { return m_nGroupID; }
            set { m_nGroupID = value; }
        }
 
        public int Index
        {
            get { return m_nIndex; }
            set { m_nIndex = value; }
        }
 
        public DateTime TimeStamp
        {
            get { return m_dt; }
            set { m_dt = value; }
        }
 
        public bool AutoLabeled
        {
            get { return m_bAutoLabeled; }
            set { m_bAutoLabeled = value; }
        }
 
        public bool IsRealData
        {
            get { return m_bIsRealData; }
        }
 
        public int Height
        {
            get { return m_nHeight; }
        }
 
        public int Width
        {
            get { return m_nWidth; }
        }
 
        public int Channels
        {
            get { return m_nChannels; }
        }
 
        public int Label
        {
            get { return m_nLabel; }
        }
 
        public int OriginalLabel
        {
            get { return m_nOriginalLabel; }
            set { m_nOriginalLabel = value; }
        }
 
        public byte[] ByteData
        {
            get { return m_rgByteData; }
        }
 
        public double[] RealDataD
        {
            get { return m_rgRealDataD; }
        }
 
        public float[] RealDataF
        {
            get { return m_rgRealDataF; }
        }
 
        public int Boost
        {
            get { return m_nBoost; }
            set { m_nBoost = value; }
        }
 
        public void ResetBoost()
        {
            m_nBoost = m_nOriginalBoost;
        }
 
        public DATA_FORMAT DataCriteriaFormat
        {
            get { return m_dataCriteriaFormat; }
            set { m_dataCriteriaFormat = value; }
        }
 
        public byte[] DataCriteria
        {
            get { return m_rgDataCriteria; }
            set { m_rgDataCriteria = value; }
        }
 
        public DATA_FORMAT DebugDataFormat
        {
            get { return m_debugDataFormat; }
            set { m_debugDataFormat = value; }
        }
 
        public byte[] DebugData
        {
            get { return m_rgDebugData; }
            set { m_rgDebugData = value; }
        }
 
        public string Description
        {
            get { return m_strDesc; }
            set { m_strDesc = value; }
        }
 
        public ANNOTATION_TYPE annotation_type
        {
            get { return m_nAnnotationType; }
            set { m_nAnnotationType = value; }
        }
 
        public AnnotationGroupCollection annotation_group
        {
            get { return m_rgAnnotationGroup; }
            set { m_rgAnnotationGroup = value; }
        }
 
        public SimpleDatum Resize(int nH, int nW)
        {
            Image bmp = ImageData.GetImage(new Datum(this));
            Bitmap bmpNew = ImageTools.ResizeImage(bmp, nH, nW);
            Datum d = ImageData.GetImageData(bmpNew, this);
 
            bmp.Dispose();
            bmpNew.Dispose();
 
            return d;
        }
 
        public override string ToString()
        {
            string strOut = "Idx = " + m_nIndex.ToString("N0");
 
            strOut += "; Label = " + m_nLabel.ToString();
            strOut += "; Boost = " + m_nBoost.ToString();
 
            if (m_dt != DateTime.MinValue)
                strOut += "; Time = " + m_dt.ToString();
 
            if (!string.IsNullOrEmpty(m_strDesc))
                strOut += "; Desc = " + m_strDesc;
 
            return strOut;
        }
 
        public string ToArrayAsString(int nMaxItems)
        {
            string str = "";
 
            if (m_bIsRealData)
            {
                if (m_rgRealDataD != null)
                {
                    for (int i = 0; i < m_rgRealDataD.Length && i < nMaxItems; i++)
                    {
                        str += m_rgRealDataD[i].ToString() + ",";
                    }
                }
                else if (m_rgRealDataF != null)
                {
                    for (int i = 0; i < m_rgRealDataF.Length && i < nMaxItems; i++)
                    {
                        str += m_rgRealDataF[i].ToString() + ",";
                    }
                }
                else
                {
                    str = "No Real Data Found!";
                }
            }
            else
            {
                for (int i = 0; i < m_rgByteData.Length && i < nMaxItems; i++)
                {
                    str += m_rgByteData[i].ToString() + ",";
                }
            }
 
            return str.TrimEnd(',');
        }
 
 
        public Bytemap ToBytemap()
        {
            if (m_rgByteData == null)
                throw new Exception("Bytemaps are only supported with byte based data.");
 
            return new Bytemap(m_nChannels, m_nHeight, m_nWidth, m_rgByteData);
        }
 
        public static bool AccumulateMean(ref double[] rgdfMean, SimpleDatum sd, int nTotal)
        {
            if (rgdfMean == null)
                rgdfMean = new double[sd.ItemCount];
 
            if (sd.IsRealData)
            {
                if (sd.RealDataD != null)
                {
                    for (int i = 0; i < sd.ItemCount; i++)
                    {
                        rgdfMean[i] += sd.RealDataD[i] / nTotal;
                    }
                }
                else if (sd.RealDataF != null)
                {
                    for (int i = 0; i < sd.ItemCount; i++)
                    {
                        rgdfMean[i] += sd.RealDataF[i] / nTotal;
                    }
                }
                else
                {
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
            }
            else
            {
                for (int i = 0; i < sd.ItemCount; i++)
                {
                    rgdfMean[i] += (double)sd.ByteData[i] / (double)nTotal;
                }
            }
 
            return true;
        }
 
        public static SimpleDatum CalculateMean(Log log, SimpleDatum[] rgImg, WaitHandle[] rgAbort)
        {
            if (rgImg.Length < 2)
                throw new Exception("There must be at least 2 images in the simple datum array.");
 
            float[] rgSums;
 
            if (rgImg[0].ByteData != null)
                rgSums = new float[rgImg[0].ByteData.Length];
            else if (rgImg[0].RealDataD != null)
                rgSums = new float[rgImg[0].RealDataD.Length];
            else if (rgImg[0].RealDataF != null)
                rgSums = new float[rgImg[0].RealDataF.Length];
            else
                throw new Exception("No data in rgImg[0]!");
 
            Stopwatch sw = new Stopwatch();
 
            try
            {
                sw.Start();
 
                int nCount = 0;
                int nHeight = 0;
                int nWidth = 0;
                for (int i = 0; i < rgImg.Length && i < 100; i++)
                {
                    nHeight = Math.Max(nHeight, rgImg[i].Height);
                    nWidth = Math.Max(nWidth, rgImg[i].Width);
                }
 
                for (int i = 0; i < rgImg.Length; i++)
                {
                    if (rgImg[i] != null)
                    {
                        if (rgImg[i].Height != nHeight || rgImg[i].Width != nWidth)
                            continue;
 
                        if (rgImg[i].ByteData != null)
                        {
                            for (int n = 0; n < rgSums.Length; n++)
                            {
                                rgSums[n] += rgImg[i].ByteData[n];
                            }
                        }
                        else if (rgImg[i].RealDataD != null)
                        {
                            for (int n = 0; n < rgSums.Length; n++)
                            {
                                rgSums[n] += (float)rgImg[i].RealDataD[n];
                            }
                        }
                        else if (rgImg[i].RealDataF != null)
                        {
                            for (int n = 0; n < rgSums.Length; n++)
                            {
                                rgSums[n] += (float)rgImg[i].RealDataF[n];
                            }
                        }
                        else
                        {
                            throw new Exception("No data in rgImg[" + i.ToString() + "]!");
                        }
 
                        nCount++;
 
                        if (sw.Elapsed.TotalMilliseconds > 2000)
                        {
                            double dfPct = (double)i / (double)rgImg.Length;
                            log.WriteLine("processing mean (" + dfPct.ToString("P") + ")");
                            sw.Restart();
 
                            if (rgAbort != null)
                            {
                                if (EventWaitHandle.WaitAny(rgAbort, 0) != EventWaitHandle.WaitTimeout)
                                    return null;
                            }
                        }
                    }
                }
 
                if (rgImg[0].ByteData != null)
                {
                    byte[] rgbMean = new byte[rgSums.Length];
 
                    for (int n = 0; n < rgSums.Length; n++)
                    {
                        rgbMean[n] = (byte)(rgSums[n] / (float)nCount);
                    }
 
                    SimpleDatum d = new SimpleDatum(rgImg[0], false);
                    d.SetData(new List<byte>(rgbMean), -1, true);
                    return d;
                }
                else if (rgImg[0].RealDataD != null)
                {
                    double[] rgdfMean = new double[rgSums.Length];
 
                    for (int n = 0; n < rgSums.Length; n++)
                    {
                        rgdfMean[n] = (double)rgSums[n] / nCount;
                    }
 
                    SimpleDatum d = new SimpleDatum(rgImg[0], false);
                    d.SetData(new List<double>(rgdfMean), -1, true);
                    return d;
                }
                else if (rgImg[0].RealDataF != null)
                {
                    float[] rgfMean = new float[rgSums.Length];
 
                    for (int n = 0; n < rgSums.Length; n++)
                    {
                        rgfMean[n] = (float)rgSums[n] / nCount;
                    }
 
                    SimpleDatum d = new SimpleDatum(rgImg[0], false);
                    d.SetData(new List<float>(rgfMean), -1, true);
                    return d;
                }
                else
                {
                    throw new Exception("SimpleDatum: Both the RealDataD and RealDataF are null!");
                }
            }
            finally
            {
            }
        }
 
        public static byte[] SaveAnnotationDataToDataCriteriaByteArray(ANNOTATION_TYPE type, AnnotationGroupCollection annotations)
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write((int)type);
 
                int nCount = 0;
                if (annotations != null)
                    nCount = annotations.Count;
 
                bw.Write(nCount);
 
                if (annotations != null)
                {
                    for (int i = 0; i < annotations.Count; i++)
                    {
                        annotations[i].Save(bw);
                    }
                }
 
                bw.Flush();
                return ms.ToArray();
            }
        }
 
        public void SaveAnnotationDataToDataCriteria()
        {
            DataCriteria = SaveAnnotationDataToDataCriteriaByteArray(m_nAnnotationType, m_rgAnnotationGroup);
            DataCriteriaFormat = DATA_FORMAT.ANNOTATION_DATA;
        }
 
        public static AnnotationGroupCollection LoadAnnotationDataFromDataCriteria(byte[] rg, DATA_FORMAT fmt, out ANNOTATION_TYPE type)
        {
            type = ANNOTATION_TYPE.NONE;
 
            if (rg == null || fmt != DATA_FORMAT.ANNOTATION_DATA)
                return null;
 
            using (MemoryStream ms = new MemoryStream(rg))
            using (BinaryReader br = new BinaryReader(ms))
            {
                type = (ANNOTATION_TYPE)br.ReadInt32();
                AnnotationGroupCollection rgGroups = new AnnotationGroupCollection();
 
                int nCount = br.ReadInt32();
                if (nCount > 0)
                {
                    for (int i = 0; i < nCount; i++)
                    {
                        rgGroups.Add(AnnotationGroup.Load(br));
                    }
                }
 
                return rgGroups;
            }
        }
 
        public bool LoadAnnotationDataFromDataCriteria()
        {
            m_rgAnnotationGroup = LoadAnnotationDataFromDataCriteria(DataCriteria, DataCriteriaFormat, out m_nAnnotationType);
 
            if (m_rgAnnotationGroup == null)
                return false;
 
            return true;
        }
 
        public void SaveInfo(string strFile)
        {
            using (StreamWriter sw = new StreamWriter(strFile + ".txt"))
            {
                sw.WriteLine("Index = " + Index.ToString());
                sw.WriteLine("ImageID = " + ImageID.ToString());
                sw.WriteLine("VirtualID = " + VirtualID.ToString());
                sw.WriteLine("Label = " + Label.ToString());
                sw.WriteLine("AutoLabeled = " + AutoLabeled.ToString());
                sw.WriteLine("Boost = " + Boost.ToString());
                sw.WriteLine("SourceID = " + SourceID.ToString());
                sw.WriteLine("OriginalSourceID = " + OriginalSourceID.ToString());
                sw.WriteLine("Description = " + Description);
                sw.WriteLine("Time = " + TimeStamp.ToString());
                sw.WriteLine("Size = {1," + Channels.ToString() + "," + Height.ToString() + "," + Width.ToString() + "}");
            }
        }
 
        public static SimpleDatum LoadInfo(string strFile)
        {
            using (StreamReader sr = new StreamReader(strFile))
            {
                string strVal = parseValue(sr.ReadLine(), '=');
                int nIndex = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                int nImageID = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                int nVirtualID = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                int nLabel = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                bool bAutoLabeled = bool.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                int nBoost = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                int nSrcId = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                int nOriginalSrcId = int.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                string strDesc = strVal;
 
                strVal = parseValue(sr.ReadLine(), '=');
                DateTime dt = DateTime.Parse(strVal);
 
                strVal = parseValue(sr.ReadLine(), '=');
                strVal = strVal.Trim('{', '}');
                string[] rgstr = strVal.Split(',');
 
                int nChannels = int.Parse(rgstr[1]);
                int nHeight = int.Parse(rgstr[2]);
                int nWidth = int.Parse(rgstr[3]);
 
                return new SimpleDatum(false, nChannels, nWidth, nHeight, nLabel, dt, nBoost, bAutoLabeled, nIndex, nVirtualID, nImageID, nSrcId, nOriginalSrcId);
            }
        }
 
        private static string parseValue(string str, char chDelim)
        {
            int nPos = str.LastIndexOf(chDelim);
            if (nPos < 0)
                return str;
 
            return str.Substring(nPos + 1).Trim();
        }
 
        public static List<SimpleDatum> LoadFromPath(string strPath)
        {
            string[] rgstrFiles = Directory.GetFiles(strPath, "*.txt");
            List<SimpleDatum> rgData = new List<SimpleDatum>();
 
            foreach (string strFile in rgstrFiles)
            {
                rgData.Add(SimpleDatum.LoadInfo(strFile));
            }
 
            return rgData;
        }
 
        public static float[] Transpose(float[] rg, int nH, int nW, int nDim = 1)
        {
            float[] rgT = new float[rg.Length];
 
            for (int i = 0; i < nH; i++)
            {
                for (int j = 0; j < nW; j++)
                {
                    int nSrcIdx = (i * nW + j) * nDim;
                    int nDstIdx = (j * nH + i) * nDim;
 
                    if (nDim == 1)
                        rgT[nDstIdx] = rg[nSrcIdx];
                    else
                        Array.Copy(rg, nSrcIdx, rgT, nDstIdx, nDim);
                }
            }
 
            return rgT;
        }
 
        public static double[] Transpose(double[] rg, int nH, int nW, int nDim = 1)
        {
            double[] rgT = new double[rg.Length];
 
            for (int i = 0; i < nH; i++)
            {
                for (int j = 0; j < nW; j++)
                {
                    int nSrcIdx = (i * nW + j) * nDim;
                    int nDstIdx = (j * nH + i) * nDim;
 
                    if (nDim == 1)
                        rgT[nDstIdx] = rg[nSrcIdx];
                    else
                        Array.Copy(rg, nSrcIdx, rgT, nDstIdx, nDim);
                }
            }
 
            return rgT;
        }
    }
 
    [Serializable]
    public class SimpleDatumCollection : IEnumerable<SimpleDatum>
    {
        string m_strName;
        SimpleDatum[] m_rgItems = null;
        List<int> m_rgShape;
        [NonSerialized]
        object m_tag = null;
 
        public SimpleDatumCollection(int nCount, string strName = "", List<int> rgShape = null)
        {
            m_strName = strName;
            m_rgItems = new SimpleDatum[nCount];
 
            m_rgShape = new List<int>() { nCount };
 
            if (rgShape != null)
                m_rgShape.AddRange(rgShape);
        }
 
        public object Tag
        {
            get { return m_tag; }
            set { m_tag = value; }
        }
 
        public List<int> Shape
        {
            get { return m_rgShape; }
        }
 
        public string Name
        {
            get { return m_strName; }
            set { m_strName = value; }
        }
 
        public int Count
        {
            get { return m_rgItems.Count(); }
        }
 
        public SimpleDatum this[int nIdx]
        {
            get { return m_rgItems[nIdx]; }
            set { m_rgItems[nIdx] = value; }
        }
 
        public IEnumerator<SimpleDatum> GetEnumerator()
        {
            return (IEnumerator<SimpleDatum>)m_rgItems.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return m_rgItems.GetEnumerator();
        }
    }
}