Imageset.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using MyCaffe.basecode;
using System.Threading;
using System.Diagnostics;
using MyCaffe.basecode.descriptors;
 
namespace MyCaffe.db.image
{
    public class ImageSet : IDisposable
    {
        CryptoRandom m_random = null;
        SourceDescriptor m_src;
        List<LabelSet> m_rgLabelSet = new List<LabelSet>();
        List<LabelSet> m_rgLabelSetWithData = new List<LabelSet>();
        SimpleDatum[] m_rgImages;
        List<int> m_rgIndexes = new List<int>();
        List<int> m_rgLabelIndexes = new List<int>();
        List<SimpleDatum> m_rgImagesLimitLoaded = new List<SimpleDatum>();
        SimpleDatum m_imgMean = null;
        int m_nLastFindIdx = 0;
        int m_nLastIdx = -1;
        int m_nFixedIndex = -1;
        object m_syncObj = new object();
        int m_nLoadLimit = 0;
        DB_LOAD_METHOD m_loadMethod;
        Dictionary<int, double> m_rgLabelBoosts = new Dictionary<int, double>();
        double m_dfLabelBoostTotal = 0;
        DatasetFactory m_factory;
        int m_nLastImageIdxFromLoad = 0;
        int m_nLoadedCount = 0;
        LabelStats m_rgLabelStats;
 
        public event EventHandler<CalculateImageMeanArgs> OnCalculateImageMean;
 
        public ImageSet(DatasetFactory factory, SourceDescriptor src, DB_LOAD_METHOD loadMethod, int nLoadLimit, CryptoRandom random)
        {
            m_random = random;
            m_factory = new DatasetFactory(factory);
            m_factory.Open(src.ID);
            m_loadMethod = loadMethod;
            m_nLoadLimit = nLoadLimit;
            m_src = new SourceDescriptor(src);            
            m_imgMean = null;
 
            m_rgImages = new SimpleDatum[m_src.ImageCount];
            m_rgLabelStats = new LabelStats(src.Labels.Count);
 
            foreach (LabelDescriptor label in src.Labels)
            {
                if (label.ImageCount > 0)
                {
                    m_rgLabelSet.Add(new LabelSet(label, m_random));
                }
 
                m_rgLabelStats.Add(label);
            }
        }
 
        protected ImageSet()
        {
        }
 
 
        protected virtual void Dispose(bool bDisposing)
        {
            if (m_factory != null)
            {
                m_factory.Close();
                m_factory.Dispose();
                m_factory = null;
            }
        }
 
        public void Dispose()
        {
            Dispose(true);
        }
 
        public Dictionary<int, ulong> GetQueryLabelCounts()
        {
            if (m_rgLabelStats == null)
                return new Dictionary<int, ulong>();
 
            return m_rgLabelStats.GetCounts(); ;
        }
 
        public void SetQueryLabelCount(int nLabel, int nBoost)
        {
            if (m_rgLabelStats != null)
            {
                m_rgLabelStats.UpdateLabel(nLabel);
                m_rgLabelStats.UpdateBoost(nBoost);
            }
        }
      
        public string GetQueryBoostHitPrecentsAsText()
        {
            if (m_rgLabelStats == null)
                return "n/a";
 
            return m_rgLabelStats.GetQueryBoostHitPercentsAsText();
        }
 
        public string GetQueryLabelHitPrecentsAsText()
        {
            if (m_rgLabelStats == null)
                return "n/a";
 
            return m_rgLabelStats.GetQueryLabelHitPercentsAsText();
        }
 
        public string GetQueryLabelEpocsAsText()
        {
            if (m_rgLabelStats == null)
                return "n/a";
 
            return m_rgLabelStats.GetQueryLabelEpochAsText();
        }
 
 
        public List<LabelDescriptor> GetLabels()
        {
            List<LabelDescriptor> rgLabels = new List<LabelDescriptor>();
 
            foreach (LabelSet ls in m_rgLabelSet)
            {
                rgLabels.Add(new LabelDescriptor(ls.Label));
            }
 
            return rgLabels;
        } 
 
        public string GetLabelName(int nLabel)
        {
            foreach (LabelSet ls in m_rgLabelSet)
            {
                if (ls.Label.Label == nLabel)
                    return ls.Label.Name;
            }
 
            return nLabel.ToString();
        }
 
        public void Relabel(LabelMappingCollection col)
        {
            foreach (SimpleDatum sd in m_rgImages)
            {
                sd.SetLabel(col.MapLabel(sd.OriginalLabel, sd.Boost));
            }
 
            ReloadLabelSets();
        }
 
        public ImageSet Clone()
        {
            ImageSet imgSet = new db.image.ImageSet();
 
            imgSet.m_src = new SourceDescriptor(m_src);
            imgSet.m_factory = new db.image.DatasetFactory(m_factory);
 
            foreach (LabelSet ls in m_rgLabelSet)
            {
                imgSet.m_rgLabelSet.Add(new db.image.LabelSet(ls.Label, m_random));
            }
 
            List<SimpleDatum> rgSd = new List<basecode.SimpleDatum>();
 
            foreach (SimpleDatum sd in m_rgImages)
            {
                if (sd != null)
                    rgSd.Add(new SimpleDatum(sd));
                else
                    rgSd.Add(null);
            }
 
            foreach (SimpleDatum sd in m_rgImagesLimitLoaded)
            {
                if (sd != null)
                    imgSet.m_rgImagesLimitLoaded.Add(sd);
                else
                    imgSet.m_rgImagesLimitLoaded.Add(null);
            }
 
            imgSet.m_rgImages = rgSd.ToArray();
            imgSet.m_imgMean = new SimpleDatum(m_imgMean);
            imgSet.ReloadLabelSets();
 
            return imgSet;
        }
 
        public int FindImageIndex(DateTime dt, string strDesc)
        {
            SimpleDatum[] rgImages = m_rgImages;
 
            if (m_rgImagesLimitLoaded.Count > 0)
                rgImages = m_rgImagesLimitLoaded.ToArray();
 
            for (int i = m_nLastFindIdx; i < rgImages.Length; i++)
            {
                if (rgImages[i].TimeStamp == dt && rgImages[i].Description == strDesc)
                {
                    m_nLastFindIdx = i;
                    return i;
                }
            }
 
            for (int i = 0; i < m_nLastFindIdx; i++)
            {
                if (rgImages[i].TimeStamp == dt && rgImages[i].Description == strDesc)
                {
                    m_nLastFindIdx = i;
                    return i;
                }
            }
 
            return -1;
        }
 
        public void Reset()
        {
            m_rgImagesLimitLoaded = new List<SimpleDatum>();
            m_rgIndexes = new List<int>();
            m_rgLabelStats.Reset();
        }
 
        public bool Add(int nIdx, SimpleDatum d)
        {
            if (m_nLoadLimit > 0 && m_rgImagesLimitLoaded.Count == m_nLoadLimit)
                return false;
 
            m_rgImages[nIdx] = d;
            m_nLoadedCount++;
 
            if (m_nLoadLimit > 0)
                m_rgImagesLimitLoaded.Add(d);
 
            bool bAdded = false;
 
            foreach (LabelSet ls in m_rgLabelSet)
            {
                if (ls.Label.ActiveLabel == d.Label)
                {
                    ls.Add(d);
                    bAdded = true;
                    break;
                }
            }
 
            if (!bAdded)
            {
                LabelSet ls = new LabelSet(new LabelDescriptor(d.Label, d.Label, "label #" + d.Label.ToString(), 0), m_random);
                ls.Add(d);
                m_rgLabelSet.Add(ls);
            }
 
            return true;
        }
 
        public void ReloadLabelSets()
        {
            lock (m_syncObj)
            {
                SimpleDatum[] rgImages = m_rgImages;
 
                if (m_rgImagesLimitLoaded.Count > 0)
                    rgImages = m_rgImagesLimitLoaded.ToArray();
 
                foreach (LabelSet ls in m_rgLabelSet)
                {
                    ls.Clear();
                }
 
                foreach (SimpleDatum d in rgImages)
                {
                    foreach (LabelSet ls in m_rgLabelSet)
                    {
                        if (d != null && ls.Label.ActiveLabel == d.Label)
                        {
                            ls.Add(d);
                            break;
                        }
                    }
                }
 
                CompleteLoad(0);
            }
        }
 
        public void CompleteLoad(int nLastImageIdx)
        {
            m_rgLabelSetWithData = new List<LabelSet>();
 
            foreach (LabelSet ls in m_rgLabelSet)
            {
                if (ls.Count > 0)
                    m_rgLabelSetWithData.Add(ls);
            }
 
            m_nLastImageIdxFromLoad = nLastImageIdx;
        }
 
        public SourceDescriptor Source
        {
            get { return m_src; }
        }
 
        public int SourceID
        {
            get { return m_src.ID; }
        }
 
        public string SourceName
        {
            get { return m_src.Name.Trim(); }
        }
 
        public bool IsRealData
        {
            get { return m_src.IsRealData; }
        }
 
        public int Count
        {
            get { return m_rgImages.Length; }
        }
 
        public SimpleDatum[] Images
        {
            get { return m_rgImages; }
        }
 
        private IEnumerable<SimpleDatum> getQuery(bool bSuperboostOnly, string strFilterVal = null, int? nBoostVal = null)
        {
            IEnumerable<SimpleDatum> iQuery = m_rgImages.Where(p => p != null);
 
            if (bSuperboostOnly)
            {
                if (nBoostVal.HasValue)
                {
                    int nVal = nBoostVal.Value;
 
                    if (nVal < 0)
                    {
                        nVal = Math.Abs(nVal);
                        iQuery = iQuery.Where(p => p.Boost == nVal);
                    }
                    else
                    {
                        iQuery = iQuery.Where(p => p.Boost >= nVal);
                    }
                }
                else
                {
                    iQuery = iQuery.Where(p => p.Boost > 0);
                }
            }
 
            if (!string.IsNullOrEmpty(strFilterVal))
                iQuery = iQuery.Where(p => p.Description == strFilterVal);
 
            return iQuery;
        }
 
        public int GetCount(bool bSuperboostOnly, string strFilterVal = null, int? nBoostVal = null)
        {
            IEnumerable<SimpleDatum> iQuery = getQuery(bSuperboostOnly, strFilterVal, nBoostVal);
            return iQuery.Count();
        }
 
        public List<SimpleDatum> GetImages(bool bSuperboostOnly, string strFilterVal = null, int? nBoostVal = null, int nStartIdx = 0, int nQueryCount = int.MaxValue)
        {
            IEnumerable<SimpleDatum> iQuery = getQuery(bSuperboostOnly, strFilterVal, nBoostVal);
 
            if (nStartIdx != 0 || nQueryCount != int.MaxValue)
                iQuery = iQuery.Where(p => p.Index >= nStartIdx && p.Index < nStartIdx + nQueryCount);
 
            return iQuery.ToList();
        }
 
        public List<SimpleDatum> GetImages(bool bSuperboostOnly, string strFilterVal, int? nBoostVal, int[] rgIdx)
        {
            IEnumerable<SimpleDatum> iQuery = getQuery(bSuperboostOnly, strFilterVal, nBoostVal);
 
            iQuery = iQuery.Where(p => rgIdx.Contains(p.Index));
 
            return iQuery.ToList();
        }
 
        public SimpleDatum GetImage(int nIdx, DB_LABEL_SELECTION_METHOD labelSelectionMethod, DB_ITEM_SELECTION_METHOD imageSelectionMethod, Log log, bool bLoadDataCriteria = false, bool bLoadDebugData = false)
        {
            lock (m_syncObj)
            {
                SimpleDatum[] rgImages = m_rgImages;
 
                if (m_nLoadLimit > 0 && m_rgImagesLimitLoaded.Count == m_nLoadLimit)
                    rgImages = m_rgImagesLimitLoaded.ToArray();
 
                if (rgImages.Length == 0)
                    throw new Exception("There are no images in the dataset '" + m_src.Name + "' to select from!");
 
                SimpleDatum sd = null;
 
                if ((labelSelectionMethod & DB_LABEL_SELECTION_METHOD.RANDOM) == DB_LABEL_SELECTION_METHOD.RANDOM)
                {
                    if (m_rgLabelSet.Count == 0)
                        throw new Exception("There are no label specified in the Labels table for the dataset '" + m_src.Name + "'!");
 
                    LabelSet labelSet = getLabelSet(labelSelectionMethod);
                    if (labelSet != null)
                        sd = labelSet.GetImage(nIdx, imageSelectionMethod);
                }
 
                int nImageIdx = 0;
 
                if (sd == null)
                {
                    sd = LabelSet.GetImage(rgImages, m_rgIndexes, rgImages.Length, nIdx, m_random, imageSelectionMethod, ref m_nLastIdx, ref m_nFixedIndex, out nImageIdx);
                }
 
 
                //-----------------------------------------
                //  Handle dynamic loading of the image.
                //-----------------------------------------
 
                bool bRawDataLoaded = false;
 
                if (sd == null)
                {
                    int nRetries = 1;
 
                    if ((imageSelectionMethod & DB_ITEM_SELECTION_METHOD.RANDOM) == DB_ITEM_SELECTION_METHOD.RANDOM)
                        nRetries = 5;
 
                    for (int i = 0; i < nRetries; i++)
                    {
                        sd = m_factory.LoadImageAt(nImageIdx, bLoadDataCriteria, bLoadDebugData);
                        if (sd != null)
                        {
                            bRawDataLoaded = true;
                            Add(nImageIdx, sd);
                            break;
                        }
 
                        if (i < nRetries - 1)
                            nImageIdx = m_random.Next(rgImages.Length);
                    }
 
                    if (sd == null)
                        log.WriteLine("WARNING! The dataset needs to be re-indexed. Could not find the image at index " + nImageIdx.ToString() + " - attempting several random queries to get an image.");
                }
 
                if (!bRawDataLoaded)
                    m_factory.LoadRawData(sd, bLoadDebugData, bLoadDataCriteria);
 
                return sd;
            }
        }
 
        public SimpleDatum GetImage(int nImageID)
        {
            lock (m_syncObj)
            {
                List<SimpleDatum> rgSd = m_rgImages.Where(p => p != null && p.ImageID == nImageID).ToList();
                if (rgSd.Count > 0)
                    return rgSd[0];
 
                SimpleDatum sd = m_factory.LoadImage(nImageID);
                if (sd != null)
                    Add(sd.Index, sd);
 
                return sd;
            }
        }
 
        public LabelSet GetLabelSet(int nLabel)
        {
            foreach (LabelSet ls in m_rgLabelSet)
            {
                if (ls.Label.ActiveLabel == nLabel)
                    return ls;
            }
 
            return null;
        }
 
        private LabelSet getLabelSet(DB_LABEL_SELECTION_METHOD labelSelectionMethod)
        {
            double dfBoostTotal = m_dfLabelBoostTotal;
            Dictionary<int, double> rgBoosts = m_rgLabelBoosts;
            int nIdx;
 
            if ((labelSelectionMethod & DB_LABEL_SELECTION_METHOD.BOOST) != DB_LABEL_SELECTION_METHOD.BOOST)
            {
                if (m_rgLabelSetWithData.Count == 0)
                    return null;
 
                if (m_rgLabelIndexes.Count == 0)
                {
                    for (int i = 0; i < m_rgLabelSetWithData.Count; i++)
                    {
                        m_rgLabelIndexes.Add(i);
                    }
                }
 
                nIdx = m_random.Next(m_rgLabelIndexes.Count);
                nIdx = m_rgLabelIndexes[nIdx];
                m_rgLabelIndexes.Remove(nIdx);
 
                return m_rgLabelSetWithData[nIdx];
            }
 
 
            //---------------------------------------------
            //  Handle Label Sets with label boost.
            //---------------------------------------------
            else
            {
                double dfVal = m_random.NextDouble() * dfBoostTotal;
                double dfTotal = 0;
 
                nIdx = m_rgLabelSet.Count - 1;
 
                for (int i = 0; i < m_rgLabelSet.Count; i++)
                {
                    int nLabel = m_rgLabelSet[i].Label.ActiveLabel;
 
                    if (rgBoosts != null && rgBoosts.ContainsKey(nLabel))
                        dfTotal += (double)rgBoosts[nLabel];
                    else
                        dfTotal += 1;
 
                    if (dfTotal >= dfVal)
                    {
                        nIdx = i;
                        break;
                    }
                }
 
                return m_rgLabelSet[nIdx];
            }
        }
 
        public void SetImageMean(SimpleDatum d)
        {
            m_imgMean = d;
        }
 
        public SimpleDatum GetImageMean(Log log, WaitHandle[] rgAbort)
        {
            if (m_imgMean != null)
                return m_imgMean;
 
            if (m_rgImages.Length == 0)
            {
                if (log != null)
                    log.WriteLine("WARNING: Cannot create image mean with no images!");
                return null;
            }
 
            if (m_loadMethod != DB_LOAD_METHOD.LOAD_ALL)
                throw new Exception("Can only create image mean when using LOAD_ALL.");
 
            if (m_nLoadLimit != 0)
                throw new Exception("Can only create image mean when LoadLimit = 0.");
 
            if (OnCalculateImageMean != null)
            {
                CalculateImageMeanArgs args = new CalculateImageMeanArgs(m_rgImages);
                OnCalculateImageMean(this, args);
 
                if (args.Cancelled)
                    return null;
 
                m_imgMean = args.ImageMean;
                return m_imgMean;
            }
 
            m_imgMean = SimpleDatum.CalculateMean(log, m_rgImages, rgAbort);
            m_imgMean.SetLabel(0);
 
            return m_imgMean;
        }
 
        public void UpdateLabelBoosts(int nProjectId)
        {
            List<LabelBoostDescriptor> rgBoosts = m_factory.GetLabelBoosts(nProjectId, m_src.ID);
            m_rgLabelBoosts = new Dictionary<int, double>();
 
            m_dfLabelBoostTotal = 0;
 
            foreach (LabelBoostDescriptor boost in rgBoosts)
            {
                m_dfLabelBoostTotal += (double)boost.Boost;
 
                int nLabel = boost.Label;
                double dfBoost = (double)boost.Boost;
 
                if (!m_rgLabelBoosts.ContainsKey(nLabel))
                    m_rgLabelBoosts.Add(nLabel, dfBoost);
                else
                    m_rgLabelBoosts[nLabel] = dfBoost;
            }
        }
 
        public void SetLabelMapping(LabelMapping map)
        {
            m_factory.SetLabelMapping(map, m_src.ID);
        }
 
        public void UpdateLabelMapping(int nNewLabel, List<int> rgOriginalLabels)
        {
            m_factory.UpdateLabelMapping(nNewLabel, rgOriginalLabels, m_src.ID);
        }
 
        public void ResetLabels(int nProjectId)
        {
            m_factory.ResetLabels(nProjectId, m_src.ID);
        }
 
        public void DeleteLabelBoosts(int nProjectId)
        {
            m_factory.DeleteLabelBoosts(nProjectId, m_src.ID);
        }
 
        public void AddLabelBoost(int nProjectId, int nLabel, double dfBoost)
        {
            m_factory.AddLabelBoost(nProjectId, nLabel, dfBoost, m_src.ID);
        }
 
        public string GetLabelBoostsAsText(int nProjectId)
        {
            return m_factory.GetLabelBoostsAsText(nProjectId, m_src.ID);
        }
 
        public Dictionary<int, int> LoadLabelCounts()
        {
            return m_factory.LoadLabelCounts(m_src.ID);
        }
 
        public void UpdateLabelCounts(int nProjectId)
        {
            m_factory.UpdateLabelCounts(m_src.ID, nProjectId);
        }
 
        public string GetLabelCountsAsText()
        {
            return m_factory.GetLabelCountsAsText(m_src.ID);
        }
 
        public void Unload()
        {
            lock (m_syncObj)
            {
                for (int i = 0; i < m_rgImages.Length; i++)
                {
                    m_rgImages[i] = null;
                }
 
                foreach (LabelSet ls in m_rgLabelSet)
                {
                    ls.Unload();
                }
 
                m_nLoadedCount = 0;
            }
        }
 
        public int GetLoadedCount()
        {
            return m_nLoadedCount;
        }
 
        public int GetTotalCount()
        {
            return m_rgImages.Length;
        }
 
        public void ResetAllBoosts()
        {
            foreach (SimpleDatum sd in m_rgImages)
            {
                sd.ResetBoost();
            }
        }
 
        public List<SimpleDatum> GetImages(DateTime dt, int nImageCount, string strFilterVal = null)
        {
            if (string.IsNullOrEmpty(strFilterVal))
                return m_rgImages.Where(p => p.TimeStamp >= dt).Take(nImageCount).ToList();
            else
                return m_rgImages.Where(p => p.Description == strFilterVal && p.TimeStamp >= dt).Take(nImageCount).ToList();
        }
 
        public bool Sort(IMGDB_SORT method)
        {
            if (method == IMGDB_SORT.BYID)
                m_rgImages = m_rgImages.OrderBy(p => p.ImageID).ToArray();
            else if (method == IMGDB_SORT.BYID_DESC)
                m_rgImages = m_rgImages.OrderByDescending(p => p.ImageID).ToArray();
            else if (method == IMGDB_SORT.BYIDX)
                m_rgImages = m_rgImages.OrderBy(p => p.Index).ToArray();
            else if (method == IMGDB_SORT.BYDESC)
                m_rgImages = m_rgImages.OrderBy(p => p.Description).ToArray();
            else if (method == IMGDB_SORT.BYTIME)
                m_rgImages = m_rgImages.OrderBy(p => p.TimeStamp).ToArray();
            else if ((method & (IMGDB_SORT.BYDESC | IMGDB_SORT.BYTIME)) == (IMGDB_SORT.BYDESC | IMGDB_SORT.BYTIME))
                m_rgImages = m_rgImages.OrderBy(p => p.Description).ThenBy(p => p.TimeStamp).ToArray();
            else
                return false;
 
            return true;
        }
    }
}