ImageSet2.cs

using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace MyCaffe.db.image
{
    public class ImageSet2 : ImageSetBase, IDisposable
    {
        CryptoRandom m_random;
        DB_LOAD_METHOD m_loadMethod;
        MasterList m_masterList = null;
        MasterIndexes m_masterIdx = null;
        List<WaitHandle> m_rgAbort = new List<WaitHandle>();
        ManualResetEvent m_evtCancel = new ManualResetEvent(false);
        Log m_log;
        TYPE m_type;
 
        public event EventHandler<CalculateImageMeanArgs> OnCalculateImageMean;
 
        public enum TYPE
        {
            TRAIN,
            TEST
        }
 
        public ImageSet2(TYPE type, Log log, DatasetFactory factory, SourceDescriptor src, DB_LOAD_METHOD loadMethod, CryptoRandom random, WaitHandle[] rgAbort)
            : base(factory, src)
        {
            m_type = type;
            m_log = log;
            m_loadMethod = loadMethod;
            m_random = random;
 
            m_rgAbort.Add(m_evtCancel);
            if (rgAbort.Length > 0)
                m_rgAbort.AddRange(rgAbort);
        }
 
        protected override void Dispose(bool bDisposing)
        {
            m_evtCancel.Set();
 
            if (m_masterIdx != null)
            {
                m_masterIdx.Dispose();
                m_masterIdx = null;
            }
 
            if (m_masterList != null)
            {
                m_masterList.Dispose();
                m_masterList = null;
            }
 
            base.Dispose(bDisposing);
        }
 
        public QueryState Initialize(bool bSilentLoad, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, int nMaxLoadCount = 0, bool bVerify = false)
        {
            if (m_masterList == null)
            {
                m_masterList = new MasterList(m_random, m_log, m_src, m_factory, m_rgAbort, nMaxLoadCount);
 
                if (OnCalculateImageMean != null)
                    m_masterList.OnCalculateImageMean += OnCalculateImageMean;
 
                if (m_loadMethod == DB_LOAD_METHOD.LOAD_ALL || m_loadMethod == DB_LOAD_METHOD.LOAD_EXTERNAL || m_loadMethod == DB_LOAD_METHOD.LOAD_ON_DEMAND_BACKGROUND)
                    m_masterList.Load(bSilentLoad);
            }
 
            if (m_masterIdx == null || m_masterIdx.LoadLimit != nMaxLoadCount)
                m_masterIdx = new MasterIndexes(m_random, m_src, nMaxLoadCount);
 
            QueryState state = new QueryState(m_masterIdx, bUseUniqueLabelIndexes, bUseUniqueImageIndexes);
 
            if (m_loadMethod == DB_LOAD_METHOD.LOAD_ALL)
            {
                m_masterList.WaitForLoadingToComplete(m_rgAbort);
 
                if (bVerify)
                    m_masterList.Verify(m_masterIdx);
            }
 
            return state;
        }
 
        public bool WaitForLoadingToComplete(int nWait = int.MaxValue)
        {
            return m_masterList.WaitForLoadingToComplete(m_rgAbort, nWait);
        }
 
        public DB_LOAD_METHOD LoadMethod
        {
            get { return m_loadMethod; }
        }
 
        public bool IsRefreshRunning
        {
            get { return m_masterList.IsRefreshRunning; }
        }
 
        public bool StartRefresh(double dfReplacementPct = 0.25)
        {
            return m_masterList.StartRefresh(dfReplacementPct);
        }
 
        public bool WaitForRefreshToComplete(int nWait = int.MaxValue)
        {
            return m_masterList.WaitForRefreshToComplete(m_rgAbort, nWait);
        }
 
        public void StopRefresh()
        {
            m_masterList.StopRefresh();
        }
 
        public TYPE ImageSetType
        {
            get { return m_type; }
        }
 
        public bool Load()
        {
            return m_masterList.Load();
        }
 
        public void Unload(bool bReload)
        {
            m_masterList.Unload(bReload);
        }
 
        public QueryState CreateQueryState(bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
        {
            return new QueryState(m_masterIdx, bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort);
        }
 
        public int GetTotalCount()
        {
            return m_masterList.GetTotalCount();
        }
 
        public int GetLoadedCount()
        {
            return m_masterList.GetLoadedCount();
        }
 
        public SimpleDatum GetImageMean(Log log, WaitHandle[] rgAbort, bool bQueryOnly)
        {
            return m_masterList.GetImageMean(log, rgAbort, bQueryOnly);
        }
 
        public List<DbItem> ReloadIndexing()
        {
            List<DbItem> rgItems = m_masterList.ReloadIndexing();
            m_masterIdx.Reload(rgItems);
            return rgItems;
        }
 
        public List<DbItem> ResetLabels()
        {
            List<DbItem> rgItems = m_masterList.ResetLabels();
            m_masterIdx.Reload(rgItems);
            return rgItems;
        }
 
        public List<DbItem> Relabel(LabelMappingCollection col)
        {
            List<DbItem> rgItems = m_masterList.Relabel(col);
            m_masterIdx.Reload(rgItems);
            return rgItems;
        }
 
        public List<DbItem> ResetAllBoosts()
        {
            List<DbItem> rgItems = m_masterList.ResetAllBoosts();
            m_masterIdx.Reload(rgItems);
            return rgItems;
        }
 
        public List<LabelDescriptor> GetLabels()
        {
            return m_src.Labels;
        }
 
        public string GetLabelName(int nLabel)
        {
            foreach (LabelDescriptor label in m_src.Labels)
            {
                if (label.ActiveLabel == nLabel)
                    return label.Name;
            }
 
            return nLabel.ToString();
        }
 
        public void SetImageMean(SimpleDatum sd, bool bSave = false)
        {
            m_masterList.SetImageMean(sd, bSave);
        }
 
        public int FindImageIndex(DateTime dt, string strDesc)
        {
            List<DbItem> rgItems = m_masterIdx.FindImageIndexes(dt);
            if (rgItems.Count == 0)
                return -1;
 
            return m_masterList.FindImageIndex(rgItems, strDesc);
        }
 
        public SimpleDatum GetImage(int nImageId)
        {
            return m_masterList.FindImage(nImageId);
        }
 
        public SimpleDatum GetImage(QueryState state, DB_LABEL_SELECTION_METHOD labelSelectionMethod, DB_ITEM_SELECTION_METHOD imageSelectionMethod, Log log, int? nLabel = null, int nDirectIdx = -1, bool bLoadDataCriteria = false, bool bLoadDebugData = false)
        {
            if ((imageSelectionMethod & DB_ITEM_SELECTION_METHOD.BOOST) == DB_ITEM_SELECTION_METHOD.BOOST &&
                (labelSelectionMethod & DB_LABEL_SELECTION_METHOD.RANDOM) == DB_LABEL_SELECTION_METHOD.RANDOM)
                labelSelectionMethod |= DB_LABEL_SELECTION_METHOD.BOOST;
 
            if (!nLabel.HasValue && (labelSelectionMethod & DB_LABEL_SELECTION_METHOD.RANDOM) == DB_LABEL_SELECTION_METHOD.RANDOM)
                nLabel = state.GetNextLabel(labelSelectionMethod);
 
            int? nIdx = state.GetNextImage(imageSelectionMethod, nLabel, nDirectIdx);
 
            if (!nIdx.HasValue || nIdx.Value < 0)
            {
                nIdx = state.GetNextImage(imageSelectionMethod, nLabel, nDirectIdx);
                if (!nIdx.HasValue || nIdx.Value < 0)
                {
                    string strBoosted = ((imageSelectionMethod & DB_ITEM_SELECTION_METHOD.BOOST) == DB_ITEM_SELECTION_METHOD.BOOST) ? "Boosted" : "";
                    string strLabel = (nLabel.HasValue) ? " for label '" + nLabel.Value.ToString() + "'." : ".";
                    throw new Exception("Failed to find the image index! The data source '" + m_src.Name + "' has no " + strBoosted + " images" + strLabel + ". You may need to re-index the dataset.");
                }
            }
 
            SimpleDatum sd = m_masterList.GetImage(nIdx.Value, bLoadDataCriteria, bLoadDebugData, m_loadMethod);
            state.UpdateStats(sd);
 
            return sd;
        }
 
        public int GetCount(QueryState state, string strFilterVal = null, int? nBoostVal = null, bool bBoostValIsExact = false)
        {
            return m_masterList.GetCount(state, strFilterVal, nBoostVal, bBoostValIsExact);
        }
 
        public List<SimpleDatum> GetImages(QueryState state, int nStartIdx, int nQueryCount = int.MaxValue, string strFilterVal = null, int? nBoostVal = null, bool bBoostValIsExact = false, bool bAttemptDirectLoad = false)
        {
            return m_masterList.GetImages(state, nStartIdx, nQueryCount, strFilterVal, nBoostVal, bBoostValIsExact, bAttemptDirectLoad);
        }
 
        public List<SimpleDatum> GetImages(QueryState state, DateTime dtStart, int nQueryCount = int.MaxValue, string strFilterVal = null, int? nBoostVal = null, bool bBoostValIsExact = false)
        {
            return m_masterList.GetImages(state, dtStart, nQueryCount, strFilterVal, nBoostVal, bBoostValIsExact);
        }
 
        public List<SimpleDatum> GetImages(bool bSuperboostOnly, string strFilterVal, int? nBoostVal, int[] rgIdx)
        {
            return m_masterList.GetImages(bSuperboostOnly, strFilterVal, nBoostVal, rgIdx);
        }
 
        public List<SimpleResult> GetAllResults(bool bRequireExtraData, int nMax)
        {
            return m_factory.QueryAllResults(m_src.ID, bRequireExtraData, nMax);
        }
    }
}